Backend

Object Pool

Reuses a set of pre-initialized, expensive-to-create objects from a managed pool instead of creating and destroying them on demand, improving performance.

Front Controller

Channels all incoming requests through a single handler that centralizes cross-cutting concerns like routing, authentication, and logging before dispatching to handlers.

Read-Through Cache

A caching strategy where the cache itself loads missing data from the backing store on a miss, so application code reads only from the cache.

Write-Through Cache

A caching strategy where every write goes to the cache and the backing store synchronously, keeping the two consistent at the cost of write latency.

Write-Behind Cache

A caching strategy where writes update the cache immediately and are flushed to the backing store asynchronously, maximizing write throughput at the cost of durability.

Refresh-Ahead Cache

A caching strategy that proactively reloads hot entries before they expire, so reads of popular keys never pay miss latency.

Command Query Responsibility Segregation (CQRS)

Separates the write model that handles commands from the read model that serves queries, letting each be optimized, scaled, and evolved independently.

Event-Driven Architecture

An architectural style where components communicate by producing and reacting to events, enabling loose coupling, asynchronous flow, and independent scaling.

Idempotent Writer

A pattern that makes repeated writes safe by ensuring duplicate operations produce the same result, essential for at-least-once delivery and retries.

Producer-Consumer

A concurrency pattern where producers place work on a shared bounded queue and consumers process it independently, decoupling rates and smoothing load.

Thread Pool

A concurrency pattern that reuses a fixed set of worker threads to execute many tasks, avoiding per-task thread creation cost and bounding concurrency.

Reactor

An event-handling pattern that demultiplexes I/O events on one or few threads and dispatches them synchronously to registered handlers, enabling scalable non-blocking servers.

Optimistic Concurrency Control

A concurrency strategy that lets transactions proceed without locking and validates at commit, retrying on conflict, assuming conflicts are rare.

Pessimistic Locking

A concurrency strategy that acquires locks on data before use to prevent concurrent modification, ensuring correctness under high contention at the cost of throughput.

Two-Phase Commit (2PC)

A distributed-transaction protocol that coordinates multiple participants to commit or abort atomically through a prepare phase and a commit phase.

Model-View-Controller (MVC)

Separates an application into a model (data and rules), a view (presentation), and a controller (input handling), decoupling concerns for maintainability.

Anti-Patterns43

God Object

A single class or module that knows or does too much, concentrating most of the system's responsibilities in one place and becoming a maintenance bottleneck.

Circular Dependency

Two or more modules that depend on each other directly or transitively, forming a cycle that prevents independent building, testing, and reasoning.

Leaky Abstraction

An abstraction that fails to fully hide its underlying implementation, forcing callers to understand and depend on the details it was meant to encapsulate.

Anemic Domain Model

Domain objects that hold data but no behavior, with all logic pushed into separate service classes, draining the object model of its purpose.

Fat Controller

Web or API controllers that accumulate business logic, validation, and data access instead of delegating, becoming bloated and impossible to test or reuse.

Spaghetti Code

Code with tangled, unstructured control flow and no clear modularity, where execution jumps unpredictably and dependencies are impossible to follow.

Stringly Typed Code

Using strings to represent data that has real structure or a fixed set of values, discarding type safety and pushing errors to runtime.

Magic Strings

Hardcoded string literals that act as keys, flags, or identifiers, with no central definition, inviting typos and silent failures.

Exception Swallowing

Catching exceptions and then ignoring them, hiding failures so that errors pass silently and bugs become nearly impossible to diagnose.

N+1 Query Problem

Loading a list, then firing one extra query per row to fetch related data, turning a single page load into hundreds of round-trips.

God Table

A single table accumulating dozens or hundreds of unrelated columns for many concepts, becoming a contention and maintenance bottleneck.

Chatty Data Access

Making many fine-grained round-trips to the database for one logical operation, so network latency dominates and throughput collapses under load.

No Connection Pooling

Opening a fresh database connection per request or query and closing it after, paying high handshake cost and exhausting connection limits under load.

Busy-Waiting (Spin-Waiting)

Repeatedly polling a condition in a tight loop instead of blocking, burning CPU cycles while waiting for an event that the scheduler could deliver for free.

Lock Contention

Many threads competing for the same lock, serializing work that should run in parallel and turning a multicore machine into an expensive single-core one.

Deadlock-Prone Locking

Acquiring multiple locks in inconsistent orders so two threads can each hold one lock while waiting for the other, freezing both forever.

Broken Double-Checked Locking

A lazy-initialization idiom that checks a field outside a lock, locks, then checks again — but without proper memory barriers it returns partially constructed objects.

Thread-Per-Request Overload

Spawning a dedicated OS thread for every incoming request, so concurrency is capped by thread count and memory, collapsing under load instead of degrading gracefully.

Blocking the Event Loop

Running CPU-heavy or synchronous work on a single-threaded event loop, stalling every other in-flight request until it finishes.

Synchronous-Over-Async (sync-over-async)

Blocking a thread to wait on an asynchronous operation's result, combining the costs of both models and risking thread-pool starvation or deadlock.

Chatty I/O

Making many small, fine-grained remote or storage calls where a few coarse-grained calls would do, multiplying latency and overhead per operation.

Memory Leak

Allocating memory that is never released because references are unintentionally retained, so usage grows without bound until the process slows, thrashes, or crashes.

Unbounded Cache

A cache with no size limit, eviction, or expiry that grows until it consumes all memory and turns a performance optimization into an out-of-memory failure.

Cache Stampede (Dogpile Effect)

When a hot cache entry expires, many concurrent requests all miss and recompute it at once, hammering the backing store and amplifying load instead of absorbing it.

Retry Storm

Aggressive, uncoordinated retries during a partial outage that multiply traffic against an already-struggling dependency and turn a blip into a full collapse.

Thundering Herd

Many clients or threads waking and acting at the same instant — on a recovery, a timer, or a wakeup — creating a synchronized load spike that overwhelms the resource they target.

Head-of-Line Blocking

A single slow or stuck item at the front of a strictly ordered queue holds up everything behind it, even when the later items are unrelated and ready to proceed.

False Sharing

Independent variables that happen to live on the same CPU cache line, so updates by different cores invalidate each other's caches and silently destroy multicore performance.

Missing Back-Pressure

A producer that pushes work faster than the consumer can handle, with no mechanism to slow it down, so queues grow unbounded until memory or the downstream collapses.

Resource Leak

Acquiring file handles, sockets, connections, or threads without reliably releasing them, so a finite pool is exhausted and the application stops being able to do work.

Over-Caching

Adding caches everywhere to chase speed, multiplying staleness, invalidation bugs, and operational complexity for marginal gains that profiling never justified.

Rolling Your Own Crypto

Designing or implementing custom cryptographic algorithms or protocols instead of using vetted, standard libraries and primitives.

SQL Injection via String Concatenation

Building SQL queries by concatenating untrusted input into the query string, letting attackers alter query logic and access or destroy data.

Missing Input Validation

Accepting and processing external input without checking its type, range, format, or size, opening the door to injection, corruption, and crashes.

Trusting Client-Side Validation

Relying on browser or app-side checks as the security boundary, when any client can be bypassed and send arbitrary requests directly to the server.

Verbose Error Leakage

Returning stack traces, SQL errors, internal paths, or version details to clients, handing attackers a map of the system to exploit.

Mass Assignment

Binding incoming request data directly onto domain objects, letting attackers set fields like isAdmin or accountBalance that were never meant to be writable.

Insecure Deserialization

Deserializing untrusted data with formats or libraries that can instantiate arbitrary types, enabling remote code execution and other attacks.

Breaking Changes Without Versioning

Changing an API's contract in place without versioning or deprecation, silently breaking existing clients and eroding trust.

Ignoring Idempotency

Designing write operations that cause duplicate effects when retried, so network blips and client retries create double charges or duplicate records.

Missing Pagination (Unbounded Result Sets)

Collection endpoints that return all records at once with no pagination, causing huge payloads, slow queries, and out-of-memory failures as data grows.

Leaky API Abstraction

An API that exposes internal database schemas, implementation details, or storage structures, coupling clients to internals and blocking safe evolution.

Entity Services

Decomposing microservices around data entities (CRUD wrappers per table) rather than business capabilities, creating chatty, anemic, tightly coupled services.

Tutorials13

Migrating from Express to Fastify

Step-by-step tutorial for migrating a Node.js Express application to Fastify for better performance

Implementing Redis Caching in Node.js

Add Redis caching to your Node.js application for improved performance

Real-time Communication with WebSockets

Implement real-time features using WebSockets

How to deploy a serverless REST API on AWS Lambda

Build and deploy a production REST API using AWS Lambda and API Gateway with infrastructure as code.

How to build an HTTP API with Azure Functions

Create and deploy a serverless HTTP-triggered API on Azure Functions using the Azure CLI and a consumption plan.

How to build a CRUD API on Amazon DynamoDB

Model data and implement create, read, update, and delete operations against Amazon DynamoDB from Node.js.

How to build a CRUD API on Azure Cosmos DB

Model documents and perform CRUD operations against Azure Cosmos DB for NoSQL from a .NET application.

How to deploy a Python function on Google Cloud Functions

Write and deploy an HTTP-triggered Python function on Google Cloud Functions (2nd gen) with the gcloud CLI.

How to Build a REST API with Best Practices

Design resource-oriented routes, use correct status codes, validate input, handle errors consistently, and version your REST API.

How to Build a GraphQL Server

Define a schema, write resolvers, solve the N+1 problem with batching, and add error handling and depth limits to a GraphQL API.

How to build and test a Node.js REST API with Jest and Supertest

Build a small Express REST API and test its endpoints with Jest and Supertest, including setup and teardown.

How to test a FastAPI application with pytest and TestClient

Test a FastAPI app's endpoints using pytest and the built-in TestClient, with fixtures and dependency overrides.

How to test a Go HTTP API with httptest

Write fast, isolated tests for a Go HTTP handler using the standard library's net/http/httptest package.

Blueprints9

Express to Fastify Blueprint

Node.js backend migration from Express to Fastify

Java EE on WebSphere to Spring Boot Blueprint

Migrate Java EE applications off WebSphere onto Spring Boot with embedded servers, externalized config, and container-native packaging.

.NET Framework to .NET 8 Modernization Blueprint

Migrate legacy .NET Framework applications to cross-platform .NET 8 with the SDK project format, modern hosting, and EF Core.

Apache Struts to Spring MVC Blueprint

Replace legacy Apache Struts web applications with Spring MVC to remove unmaintained framework risk and modernize the web tier.

Ruby on Rails Major Version Upgrade Blueprint

Upgrade a Ruby on Rails application across major versions with incremental dual-boot, deprecation cleanup, and gem compatibility work.

Legacy PHP to Laravel Blueprint

Modernize procedural or legacy-framework PHP into a structured Laravel application with Composer, an ORM, and modern PHP 8 features.

Node.js Callbacks to Async and ESM Blueprint

Modernize callback-based CommonJS Node.js services to async/await with promises and ES modules for cleaner control flow.

Scala Akka Actor Modernization Blueprint

Modernize legacy Scala Akka classic actor systems to typed actors and current streaming APIs while addressing licensing changes.

Big Ball of Mud to Modular Monolith Blueprint

Restructure a tangled monolith into a modular monolith with enforced module boundaries before considering any service split.

Migrations10

.NET 8 to .NET 9 Migration

Upgrade from .NET 8 LTS to .NET 9 with improved performance and new features

.NET Framework to .NET 8 Migration

Modernize from .NET Framework to cross-platform .NET 8 (ASP.NET Core, modern configuration, updated dependencies)

Express.js to Fastify Migration

Migrate Express middleware and routes to Fastify with schema validation and performance tuning

Express.js to NestJS Migration

Migrate Express.js REST API to structured NestJS with TypeScript

Laravel 10 to Laravel 11 Migration

Upgrade Laravel from 10 to 11 with new directory structure

PHP 5 to PHP 8 Migration

Upgrade legacy PHP 5 codebases to PHP 8 with framework/library modernization

PHP 7 to PHP 8 Migration

Upgrade PHP 7 codebases to PHP 8 with dependency updates and compatibility testing

Rails 6 to Rails 7 Migration

Upgrade a Rails 6 app to Rails 7, addressing breaking changes and updating JS/CSS tooling

Spring Boot 2 to Spring Boot 3 Migration

Upgrade Spring Boot 2.x to 3.x with Java 17+ and Jakarta EE

Spring MVC to Spring WebFlux Migration

Migrate Spring MVC apps to reactive Spring WebFlux where it provides clear value

Products4

Fastify

Fast and low overhead web framework for Node.js

Quarkus

Kubernetes-native Java framework for cloud deployments

Laravel

PHP web application framework with expressive syntax

Phoenix

Elixir web framework for productive development

Playbooks7

Java EE to Spring Boot Program Playbook

An enterprise program for migrating Java EE applications to Spring Boot with modern build, runtime, and deployment practices.

.NET Framework to .NET Modernization Program Playbook

A portfolio program for moving .NET Framework applications to modern cross-platform .NET with containerized, cloud-ready deployment.

Rails Major-Version Upgrade Program Playbook

A staged program for upgrading Ruby on Rails applications across major versions with dual-boot validation and gem modernization.

PHP Major-Version Upgrade Program Playbook

A program for upgrading PHP applications across major versions with automated rectoring, dependency updates, and staged rollout.

Node.js Major-Version Upgrade Program Playbook

A fleet-wide program for upgrading Node.js services across major runtime versions with dependency and ESM modernization.

Modular Monolith Adoption Program Playbook

A program to restructure a tangled monolith into a modular monolith with enforced boundaries before any service extraction.