Building software that scales with Typescript

The true measure of a scalable project isn't performance. It's a developer's confidence in making changes without breaking things.

#1about 3 minutes

Defining the core principles of scalable software

A scalable project is defined by having readable code, a clear structure, and strong enforcement of its architecture.

#2about 2 minutes

Improving code readability with explicit type signatures

TypeScript function signatures clarify parameter and return types, allowing developers to understand behavior without reading the implementation.

#3about 5 minutes

Separating data from logic for better structure

By separating data objects from the logic that manipulates them, you can adhere to the Single Responsibility Principle and create a more maintainable structure.

#4about 6 minutes

Applying high-level architectural patterns like Clean Architecture

Organize your project into stable layers based on Clean Architecture principles, with a clear folder structure for components like APIs, managers, and data access.

#5about 5 minutes

Enforcing structure with interfaces and design patterns

Use TypeScript interfaces to enforce consistent design patterns, such as Command Query Separation (CQS), and establish clear conventions for your components.

#6about 4 minutes

Reducing the overhead and verbosity of TypeScript

Minimize TypeScript's boilerplate by leveraging type inference, preferring composition over inheritance, and using type utilities to create derivative types.

#7about 4 minutes

Measuring scalability and building confidence with tests

Evaluate your project's scalability by how easy it is to locate code for changes and build confidence using the testing trophy model, which prioritizes integration tests.

#8about 2 minutes

How to migrate legacy projects to a clean architecture

When migrating a legacy codebase, start by refactoring the peripheral layers like data access and gateways before tackling the core business logic.

#9about 2 minutes

Why folder structure still matters with modern IDEs

A deliberate folder structure is crucial for discoverability when you don't know a file's exact name and helps prevent code duplication and coupling.

#10about 2 minutes

A practical defense of the anemic domain model

While often labeled an anti-pattern, separating data from methods into an anemic domain model can be a very useful and practical pattern for structuring code.

#11about 2 minutes

A minimal mocking strategy for integration tests

For robust integration tests, mock as little as possible, focusing only on true external dependencies like third-party services to ensure tests reflect production behavior.

From learning to earning

Jobs that call for the skills explored in this talk.