Architecture

API composition is when one service calls several other services and smooshes the results together into one response.

API First Design means you write the API contract (like an OpenAPI spec) before writing any code — like drawing blueprints before building a house. Fronten

API orchestration is a central conductor that coordinates multiple API calls in a specific sequence to complete a business process.

Abstraction is hiding the messy details and showing only what matters.

You're in Europe with a US charger. You need an adapter. In code, your app expects a PaymentProcessor with a .pay() method, but the new Stripe SDK uses .

An aggregate is a cluster of domain objects that are treated as one unit for data changes.

The ambassador pattern puts a proxy between your app and the outside world that handles all the annoying connection stuff — retries, circuit breaking, rout...

An anti-corruption layer is a translator between two systems that speak different languages.

Anti-Pattern is the opposite of a design pattern — it's a commonly used approach that looks like it solves a problem but actually makes things worse.

Architecture is the master blueprint for your app — like deciding whether to build a house, apartment block, or skyscraper before laying a single brick.

An autonomous service can function independently even when other services are down. It has its own database, its own logic, and can handle requests solo.

BFF is the abbreviation for Backend for Frontend. Not your best friend — your backend's best friend for a specific client.

A backend gateway is the front door to your microservices. All client requests hit the gateway first, and it routes them to the right service.

Backend for Frontend means building a dedicated backend for each frontend type. Your mobile app needs different data shapes than your web app.

BFF (Backends for Frontends) means each frontend gets its own custom backend. The mobile app gets a backend optimized for small payloads.

Backpressure is when a system says 'slow down, I can't handle this much data.

Big Ball of Mud is the ultimate architectural anti-pattern — a system with no recognizable structure at all.

A bounded context is a boundary where a particular model and language applies. 'Customer' means one thing in Sales and something different in Shipping.

The broken windows theory in code says that once one piece of bad code exists, more bad code follows.

CQRS says: the way you write data and the way you read data should be separate systems. Writing (commands) goes to one model optimized for transactions.

A CRDT (Conflict-free Replicated Data Type) is a data structure that multiple users can edit simultaneously without conflicts.

Cell-based architecture splits your system into independent cells, each serving a subset of users.

Choreography is when services coordinate by reacting to each other's events without a central boss.

Choreography: everyone dances independently, reacting to the music (events). Orchestration: a conductor tells each musician when to play. Both work.

Circuit Breaker is like the electrical circuit breaker in your house.

Clean Architecture is like an onion with strict rules: the inner layers (your core business logic) have absolutely no idea the outer layers (databases, API...

Clean Architecture's layers go: Entities (business rules) -> Use Cases (app rules) -> Interface Adapters (controllers, presenters) -> Frameworks & Drivers...

Code rot is the slow decay of a codebase from neglect. Comments become lies. Dead code piles up. Conventions drift.

Code that works but feels... wrong. Like when food smells slightly off — it might be fine, but something isn't right.

Cohesion is how well the things inside a module belong together. High cohesion means all the stuff in a class is related — like a toolbox full of tools.

A command bus is the postal service for 'please do this' messages.

Every action in a text editor is a Command object: TypeTextCommand, DeleteWordCommand, BoldCommand.

Composition means building complex things by combining simple ones, rather than inheriting from a parent class.

Content-addressed storage stores data by its hash, not its name — deduplication and integrity verification baked directly into the model.

Context mapping is drawing the diplomatic map of your system — which bounded contexts exist, how they relate, and who's in charge.

Coupling is how much two pieces of code depend on each other. Tight coupling means changing one breaks the other — like Siamese twins.

DDD is the abbreviation for Domain-Driven Design — the practice of making your code speak fluent Business.

If you find yourself copy-pasting the same code in multiple places, STOP. Make it a reusable function instead.

The data access layer is the entire floor of your architecture that handles talking to databases.

It's like a pinky promise between two teams, but legally binding (well, technically binding). Team A says 'I promise this data will always have these colum

Instead of one giant warehouse where ALL the company's data goes (and one poor team manages it), Data Mesh says 'each team owns their own data like it's a

Database per service means each microservice gets its own private database that nobody else can touch. No shared tables, no direct queries across services.

A dead letter queue (DLQ) is where messages go to die — or more accurately, where they go when they can't be processed after multiple attempts.

You have a Coffee object. You want Coffee with Milk. Coffee with Sugar. Coffee with Milk and Sugar. With inheritance you'd need four classes.

Instead of your UserService creating its own DatabaseConnection (tight coupling), you pass the database in from outside: new UserService(db).

Dependency Inversion says high-level code shouldn't depend on low-level code — both should depend on abstractions.

Design patterns are like recipe cards for solving common coding problems.

A distributed monolith is what happens when you split your monolith into microservices but they're all still tightly coupled.

A domain model is a code representation of your real-world business.

DDD says your code should speak the same language as the business.

ESB is the short form for Enterprise Service Bus — the middleware that enterprise architects either love or love to hate.

Encapsulation is bundling data and the methods that operate on it into one unit, and hiding the internal state from the outside world.

An ESB is the central highway that all your enterprise services communicate through. It routes messages, transforms data, and orchestrates workflows.

Entropy tax is the cost you pay every time you touch a messy codebase. Every new feature takes 20% longer because the code is tangled.

An event handler is the code that says 'oh, something happened? Let me react to that.

An event mesh is like a postal system for events that knows every address across all your clouds and data centers.

Instead of storing 'balance: $100', event sourcing stores 'deposited $200, withdrew $50, withdrew $50'.

Event storming is where you put a bunch of sticky notes on a wall and map out everything that happens in your business as events.

Event-Driven Architecture is like a gossip network. When something happens (order placed!), it broadcasts the news.

Event-driven microservices communicate by publishing events instead of calling each other directly. 'Hey, an order was placed!

Eventual consistency means 'give it a moment and everything will be in sync.' Like a bank deposit — the money shows up eventually, but not instantly.

Facade Pattern is like the front desk at a hotel.

You want to create a 'notification' object but it might be an EmailNotification, SMSNotification, or PushNotification depending on user preferences.

Feature envy is when a function spends more time poking around in another class's data than its own.

Feature flag rot is when a flag has been sitting around for so long that nobody knows what it does or what breaks when you flip it.

A feature store is like a shared pantry for ML features.

A gateway wraps access to an external system behind a nice, clean interface.

A god object is a class that knows everything, does everything, and has way too much power — like a single manager running every department of a company.

The golden hammer is when you find a tool you love and use it for EVERYTHING — even when it's completely wrong for the job. Love React?

Hexagonal Architecture (aka Ports and Adapters) treats your app like a USB hub.

Inheritance lets a class take on all the properties and behaviors of another class.

An interactor is just another name for a use case — it's the code that 'interacts' with your domain to accomplish one specific task.

Interface Segregation means don't force classes to implement methods they don't need.

Inversion of Control is when a framework calls YOUR code instead of you calling the framework. You don't control the flow anymore — the framework does.

IoC is the abbreviation for Inversion of Control. It's the Hollywood Principle: 'Don't call us, we'll call you.

Don't overcomplicate things! The simplest solution that works is usually the best one.

Legacy tax is what you pay for maintaining old systems that nobody wants to touch.

Liskov Substitution says if class B extends class A, you should be able to swap B in everywhere A is used without anything breaking.

MVC is like a restaurant: the Model is the kitchen (data and logic), the View is the plate of food (what the user sees), and the Controller is the waiter (...

MVVM is MVC's cooler cousin for UI-heavy apps.

A Message Broker is the post office of your microservices world.

A Message Queue is a waiting room for tasks. Producers drop tasks in the queue, consumers pick them up and process them one at a time.

Micro frontends are microservices for the UI.

Modular Monolith is the best of both worlds: one deployable app (monolith) but organized into clear, separate modules that could become microservices somed...

A modular monolith is a single deployable app that's internally organized into independent modules with clear boundaries.

Module Federation lets separate webpack builds share code at runtime. App A can dynamically load a component from App B's bundle — no npm package needed.

Think of a newsletter. You (the publisher/subject) publish content. Your subscribers (observers) automatically get notified when new content arrives.

Onion architecture arranges code in concentric layers like an onion. The core (domain) has no dependencies. Each outer layer depends inward, never outward.

Open-Closed means your code should be open for adding new features but closed for editing old working code.

The outbox pattern solves the 'I need to update my database AND send an event, but what if one succeeds and the other fails?' problem.

Building a rocket ship when you just need a bicycle.

Platform engineering is building the roads so application developers can just drive.

Polymorphism means the same method call can do different things depending on which object it's called on. Call 'speak()' on a Dog and you get a bark.

Polyrepo is the opposite of monorepo — each service or project lives in its own separate repository.

Ports and Adapters (aka Hexagonal Architecture) means your app defines 'ports' (interfaces) and the outside world connects through 'adapters.

Premature abstraction is creating a reusable, generic solution before you have enough examples to know what the abstraction should look like.

A presenter takes raw data from your use case and formats it for display.

A process manager is the project coordinator for long-running workflows.

A projection transforms raw events into a useful read model. Every time an 'OrderPlaced' event fires, the projection updates the dashboard table.

A Proxy is a stand-in for a real object that controls access to it.

Pub/Sub is like a newspaper service. Publishers write articles and drop them off.

A read model is a database view optimized specifically for reading — denormalized, pre-computed, and shaped exactly how the UI needs it.

Refactor fatigue is when your team has refactored the same module four times in a year and nobody wants to touch it again.

Refactor tax is the extra work every feature costs because you're simultaneously refactoring underlying code. Each PR becomes 30% larger and 50% riskier.

Refactoring is improving the internal structure of code WITHOUT changing what it does from the outside.

Repository Pattern puts a layer between your business logic and your database, so your business code never writes SQL directly.

The repository pattern makes your database look like an in-memory collection. Instead of writing SQL, you call repository.findById(42) or repository.

A resumable workflow can pause, crash, and pick up exactly where it left off — checkpoints for distributed systems that can't afford to restart.

Retry Pattern is trying something again when it fails, because sometimes failures are temporary (network hiccup, brief overload).

Rewrite syndrome is the near-universal engineering urge to throw out existing code and start over. 'It would be so much cleaner if we rewrote it in Rust.

SOA is the acronym for Service Oriented Architecture — the architectural style that your company's senior architect keeps bringing up in meetings because t...

SOLID is five rules for writing code that doesn't turn into a nightmare over time. Each letter stands for a different rule.

A saga is a series of steps where each step has an undo action. If step 3 fails, you run the undo for steps 2 and 1.

The saga pattern is how you handle transactions that span multiple services. In a monolith, you'd wrap everything in one database transaction.

Screaming architecture means your folder structure screams what the app DOES, not what framework it uses.

The second system effect is when you rewrite a successful system from scratch and massively over-engineer it.

A self-contained system (SCS) is a mini-application that includes its own UI, backend, and database.

Separation of Concerns means different parts of your code should handle different concerns and not step on each other's toes.

Service Layer is the middle manager of your app. Controllers receive HTTP requests and hand off to services.

SOA is the granddaddy of microservices. It's the idea of building software as a collection of services that talk to each other over a network.

Shared database is when multiple services all read from and write to the same database.

Shotgun surgery is when one small change requires you to modify dozens of files across the codebase — like firing a shotgun and hitting everything.

The sidecar pattern attaches a helper container to your main app, like a motorcycle sidecar.

Single Responsibility means every class or function should do ONE thing and do it well.

Singleton is a pattern that ensures only ONE instance of a class exists in your entire app.

Singleton says: 'this class shall have exactly ONE instance, ever.' Database connections, config objects, loggers — things you only want created once.

Replacing a legacy system piece by piece instead of doing a risky big-bang rewrite.

You're writing a sorter and want to sort by price, name, or date depending on user choice.

A tech-debt snowball is when you avoid paying down small tech debt, it compounds, and six months later the simple feature you want to add requires rewritin...

Toggle debt is the pile of unused feature flags slowly suffocating your codebase. Every 'if (flag)' branch is cognitive load.

Toggle hygiene is the practice of cleaning up feature flags after they've served their purpose.

Turducken architecture is when you have a system nested inside another system nested inside yet another system — like the famous chicken-inside-a-duck-insi...

Ubiquitous language means developers and business people use the EXACT SAME words for the same things.

A use case is a single thing a user can do with your system — 'Place Order', 'Register Account', 'Cancel Subscription.

Vertical slice architecture organizes code by feature, not by layer.

The write model is the authoritative version of your data that handles all the business rules and commands. It's the master copy in the vault.

Don't build stuff you don't need right now.