Acceptance Testing multiple NestJS Microservices by running them a single process communicating via a memory fake.

How to make sure that memory-based fakes really behave like the production implementations they replace

Writing memory-based black-box acceptance tests for NestJS apps, testing features rather than implementation details

K8s solves a problem that your new startup probably doesn't face. Invest your resources in finding product-market fit and scale up later.

PMs make overly detailed plans without dev feedback, resulting in waste. Shorten cycle time by planning briefly then develop and iterate.

Unit tests couple us to implementation detail, restrict refactoring and don't assert that features work. Prefer bigger-scoped tests.

Microservices incur significant overheads in costs of change, runtime and complexity. Start with a monolith and break it down when needed.

Fakes are complete implementations of an API used to replace IO-bound adapters with memory-bound doubles to facilitate Acceptance Testing

Learning Tests are an easy and useful methodology for integration with new and unknown APIs, reducing stress and improving feedback times.

How I used React with TypeScript and Firebase to build my own client management system, using TDD and Acceptance Testing.

Fixture test data create stale and outdated data, and make tests unreliable. Object Builders are a better way, here's how to use them.

Relying on .env files couples your codebase to env vars, making your software harder to change. Here's how to decouple them.

Code rots because we build too many features, too fast. Emergent Design is an effective way to fight code rot and make change easier.

How I helped Versatile remove fear of change in a key subsystem by introducing TDD and refactoring to Hexagonal Architecture.

When there are too many dirty pots and plates in the sink, it's impossible to clean them. It's the same with software and technical debt.

Prototypes are a lie; when it's good enough for production, it *becomes* production. Here's how to make them easily maintainable.

Writing features we might need in the future is not only a waste of time, it makes your software harder to maintain.

Hexagonal Architecture allows us to separate pure logic from external constraints and enables writing fast, integrative acceptance tests.