Learn
Architecture & pattern guides Read the idea, build it on a Grid, prove it in a challenge. Short, practical guides — illustrated with RodGrid's own nodes — on system design, design patterns, flow modeling, and how to get the most out of the app.
Suggested path Read the concept article Build the example on your own Grid Take the linked challenge and review your score A free account saves your progress — what you've read, where you stopped and what to read next, on any device. Create a free account
Using RodGrid System Design Design Patterns Flow & Logic Low-Level Design
Using RodGrid Free Build your first diagram Place components from the palette, connect them with edges and name them, with or without an account. URL Shortener Beginner 3 minUsing RodGrid Free The node palette & component families Which family a node belongs to, which kind of Grid offers it, and what each plan can place. Weather Service URL Shortener Beginner 3 minUsing RodGrid Free Selecting & moving nodes What a drag does depends on the mode: move a node, draw a selection box, or pan the view. URL Shortener Expense Splitting Beginner 3 minUsing RodGrid Free Naming nodes: inline rename & the inspector Double-click to rename a node where it sits; open the Node Inspector when it also needs a service type, a description or a color. URL Shortener Beginner 3 minUsing RodGrid Free Connecting & styling edges Direction, labels, colour, routing styles and draggable bend points, and what a Challenge Grid leaves you. User Login Flow Beginner 3 minUsing RodGrid Free Starting from a template Create a Grid from a built-in seed or your own saved template, and know what saving a Grid as a template does to that Grid. News Feed Beginner 4 minUsing RodGrid Premium Sharing & realtime collaboration Invite links, one per person, put people on the same live Grid (Premium). Whose plan counts, what each role can do, and how to take access back. Collaborative Document Editor Chat System Beginner 3 minUsing RodGrid Free Premium Organizing large diagrams: frames, groups & annotations Frame a region you would name, group nodes you want to nudge and copy together, and leave notes and comments where the decision happened. News Feed E-Commerce Checkout Beginner 3 minUsing RodGrid Free How Challenge Mode works Pick an exercise, build against a curated palette, ask for hints, submit for AI scoring. Observer Pattern URL Shortener Beginner 4 minUsing RodGrid AI credits AI Architecture Analysis: a review of your diagram Get an AI review of the architecture you drew: what is wrong, what is at risk, and what is still undecided. URL Shortener News Feed Intermediate 4 minUsing RodGrid Free Pro Getting diagrams in and out Take a diagram out as an image on any plan; on Pro and Premium, import from Mermaid or a file, or export as Mermaid or JSON. URL Shortener Beginner 4 minUsing RodGrid AI credits Checking a diagram: Explain and Simulate Two questions about your Grid: what does it say, and what would it do under load? News Feed Intermediate 4 minUsing RodGrid Premium Snapshots: comparing a Grid with its past self Save a named milestone, diff the live Grid against it, and put the Grid back if you need to. Rate Limiter Intermediate 4 minUsing RodGrid Pro Premium Presenting a Grid: walkthroughs and scenario overlays Mark one story on the Grid with a scenario, or drive a saved tour of it with a walkthrough, without making a copy. News Feed Intermediate 4 minUsing RodGrid Free Working faster: shortcuts, search and tidy The keyboard, the quick switcher, find-on-canvas, and one-click alignment. URL Shortener Beginner 3 minUsing RodGrid Premium Publishing a Grid: public pages and embeds An invite, a public address and an embed reach three different audiences. How to publish (Premium), what stays cached, and how to take it down. Video Streaming Platform Intermediate 4 minUsing RodGrid Pro Making the catalog yours: custom components On Pro or higher, build a node the catalog doesn't have, reuse it across your Grids, and know what it keeps when it travels. Serverless Web App on AWS Enterprise Integration Hub Intermediate 5 minUsing RodGrid Premium From a picture to a model: governance and views Record who owns each node and what it runs on in its Governance fields, then read the same Grid one view at a time. Monolith to Microservices Micro-Frontend Platform Intermediate 4 minUsing RodGrid Free AI credits AI credits: what they buy and how they are spent AI features spend credits, and only one of them also asks for a plan. Where credits come from, what each run costs, which credits go first, and what happens when the price moves or the balance runs out. URL Shortener Beginner 5 minUsing RodGrid Free Your account: signing in, two-factor, and why you were signed out There is no password to lose. What there is: an optional second factor, an idle clock on live Grids, a ceiling of two signed-in browsers, and sign-ins that run out. Distributed Session Store SSO Identity Provider Beginner 4 minUsing RodGrid Free Stress testing a design before it exists Push traffic through the Grid, break it on purpose, and read where it gives way, free on every plan, with no AI and no server. Rate Limiter URL Shortener Intermediate 7 minUsing RodGrid AI credits Writing a PRD from the diagram The Grid says what is being built. Tell AI PRD what it is for, and it drafts the requirements, instructed to list the gaps as questions instead of guessing them. URL Shortener News Feed Intermediate 4 minUsing RodGrid Free AI credits Starting from a brief: the diagram generators Answer an interview and get a validated architecture Grid, or describe a design pattern and get its roles drawn. Observer Pattern Hotel Booking System Intermediate 5 minUsing RodGrid AI credits Guided challenges: four stages, one check each Walk a system-design Challenge the way an interview does, requirements before boxes, with an optional check at every stage. URL Shortener Chat System Intermediate 4 minUsing RodGrid AI credits After you submit: the score, the defense and the reference What the number is made of, how to have your reasoning graded, and what to do with the reference solution. Rate Limiter News Feed Intermediate 6 minUsing RodGrid Free Deleting a Grid, and getting it back Delete sends a Grid to the trash for 30 days. What restore brings back, and the one thing it does not. URL Shortener Beginner 3 minAll articles Build your first diagram — Place components from the palette, connect them with edges and name them, with or without an account.The node palette & component families — Which family a node belongs to, which kind of Grid offers it, and what each plan can place.Selecting & moving nodes — What a drag does depends on the mode: move a node, draw a selection box, or pan the view.Naming nodes: inline rename & the inspector — Double-click to rename a node where it sits; open the Node Inspector when it also needs a service type, a description or a color.Connecting & styling edges — Direction, labels, colour, routing styles and draggable bend points, and what a Challenge Grid leaves you.Starting from a template — Create a Grid from a built-in seed or your own saved template, and know what saving a Grid as a template does to that Grid.Sharing & realtime collaboration — Invite links, one per person, put people on the same live Grid (Premium). Whose plan counts, what each role can do, and how to take access back.Organizing large diagrams: frames, groups & annotations — Frame a region you would name, group nodes you want to nudge and copy together, and leave notes and comments where the decision happened.How Challenge Mode works — Pick an exercise, build against a curated palette, ask for hints, submit for AI scoring.AI Architecture Analysis: a review of your diagram — Get an AI review of the architecture you drew: what is wrong, what is at risk, and what is still undecided.Getting diagrams in and out — Take a diagram out as an image on any plan; on Pro and Premium, import from Mermaid or a file, or export as Mermaid or JSON.Checking a diagram: Explain and Simulate — Two questions about your Grid: what does it say, and what would it do under load?Snapshots: comparing a Grid with its past self — Save a named milestone, diff the live Grid against it, and put the Grid back if you need to.Presenting a Grid: walkthroughs and scenario overlays — Mark one story on the Grid with a scenario, or drive a saved tour of it with a walkthrough, without making a copy.Working faster: shortcuts, search and tidy — The keyboard, the quick switcher, find-on-canvas, and one-click alignment.Publishing a Grid: public pages and embeds — An invite, a public address and an embed reach three different audiences. How to publish (Premium), what stays cached, and how to take it down.Making the catalog yours: custom components — On Pro or higher, build a node the catalog doesn't have, reuse it across your Grids, and know what it keeps when it travels.From a picture to a model: governance and views — Record who owns each node and what it runs on in its Governance fields, then read the same Grid one view at a time.AI credits: what they buy and how they are spent — AI features spend credits, and only one of them also asks for a plan. Where credits come from, what each run costs, which credits go first, and what happens when the price moves or the balance runs out.Your account: signing in, two-factor, and why you were signed out — There is no password to lose. What there is: an optional second factor, an idle clock on live Grids, a ceiling of two signed-in browsers, and sign-ins that run out.Stress testing a design before it exists — Push traffic through the Grid, break it on purpose, and read where it gives way, free on every plan, with no AI and no server.Writing a PRD from the diagram — The Grid says what is being built. Tell AI PRD what it is for, and it drafts the requirements, instructed to list the gaps as questions instead of guessing them.Starting from a brief: the diagram generators — Answer an interview and get a validated architecture Grid, or describe a design pattern and get its roles drawn.Guided challenges: four stages, one check each — Walk a system-design Challenge the way an interview does, requirements before boxes, with an optional check at every stage.After you submit: the score, the defense and the reference — What the number is made of, how to have your reasoning graded, and what to do with the reference solution.Deleting a Grid, and getting it back — Delete sends a Grid to the trash for 30 days. What restore brings back, and the one thing it does not.Load balancing & horizontal scaling — Spread traffic across many identical instances and add capacity by adding boxes — once the instances are interchangeable, the balancer can tell a dead one, and you know what still does not multiply.Caching layers — A read can be answered by the browser, a CDN edge, the app's own memory, a shared cache or the database. Each layer saves something different, serves different people, and gets harder to update the closer it sits to the reader.Cache read and write strategies — Who talks to the database, the application or the cache? Read-through, write-through, write-behind, write-around and refresh-ahead each answer it differently, and each answer changes when a write counts as done, what a crash loses and how stale a read can be.SQL vs NoSQL — Relational, key-value, document and wide-column stores each serve a different access pattern: choose per workload, by how the data is written and read, not per company.Replication & read replicas — Copy data to extra nodes for read scaling and failover, knowing async replicas lag and can lose writes on failover.Conflict resolution for concurrent writes — When two replicas accept writes to the same item without seeing each other's: what last-write-wins silently throws away, how version vectors detect the conflict, how CRDTs merge it, and when the application or a person has to decide.Collaborative text editing: OT vs CRDTs — Why two people typing in the same text break each other's positions, how operational transformation rewrites each edit against the ones it missed and why most deployments give it one server per document, how sequence CRDTs give every character an identifier instead, and how to choose between them.Sharding & partitioning — Split one dataset across many nodes by a partition key: how the key decides which queries stay on one shard, range vs hash partitioning, hot keys and oversized partitions, queries and transactions that cross shards, and moving data when a shard is added.Message queues & async workers — Moving slow work out of the request into a queue that workers drain, what the caller gives up for it, why a job can run twice, and when a queue is the wrong tool.Pub/sub: topics, subscriptions & replay — One event, every subscriber: topics and subscriptions, consumers sharing one subscription's work, retention and replay for a subscriber that was down or arrives late, ordering per key, at-least-once delivery, and why one slow subscriber need not slow the others.API gateway & the edge — Which checks belong in the one entry point every request passes through, which rules stay in the services, and what that shared front door costs to run.Rate limiting — Cap how often each client may call you: deciding what counts as one client, counting with a fixed window, a sliding window or a token bucket, sharing the count across instances, and telling a refused caller when to come back.Cascading failures: how one dependency takes down its callers — How one slow dependency can exhaust the threads and connections its callers share, hop by hop, until features that never call it go down too, and which resilience pattern breaks each link of that chain.Chaos engineering & game days — Redundancy that has never met a real failure is only a claim. A chaos experiment tests it with one real fault, under a written hypothesis and a line at which it stops; a game day rehearses the people too.Service discovery & the mesh — Who turns a service name into the address of a live instance, and where: a library in the caller, something in the middle, or a mesh proxy, and what each placement costs.Microservices vs monolith — When splitting one deployable into services pays for what an in-process call costs once it crosses the network, and why a modular monolith is the usual start.Object storage & blobs — Where files belong instead of your database: whole objects under keys in a flat namespace, written and read over HTTP and replaced rather than edited; the key and metadata kept in your database; private buckets opened one operation at a time with presigned URLs; versioning against overwrites and deletes; storage classes, lifecycle rules, and a bill made of storage, requests and egress.Content-addressed storage & deduplication — Naming a blob by the hash of its bytes: why identical layers end up stored once, how the digest checks integrity and makes an object immutable and cacheable, tags and manifests as the mutable names above, chunking for dedup, garbage collection with a grace period, and what the hash does not promise.Erasure coding: durability without full copies — Store k data fragments and m parity fragments instead of full copies, so that with a code like Reed-Solomon any k rebuild the data: far less disk than replication, paid for in placement rules, heavier repairs and slower reads while a data fragment is missing.Full-text search — Why LIKE cannot serve a search box, how text becomes terms, and how a search engine ranks the matches: TF-IDF, BM25, field boosts, static signals, typo tolerance, and an index kept in step with the database.Observability: metrics, logs & alerting — What each kind of telemetry answers and what it costs: counters, gauges and histograms whose labels stay bounded, structured logs joined by a request id, getting both out of the process without slowing a request, and alerts on what users feel rather than on what the machines feel.Distributed tracing — Follow one request across every service it touches: spans and the tree they form, trace context carried in headers and through queues, collectors that stay off the request path, why traces are sampled and what tail sampling demands, and the stored traces and dependency map that come out the other end.Authentication: passwords, MFA & identity providers — Proving who is calling: why passwords are stored with a slow, salted key-derivation function, why a leaked hash table and a stuffed login form are different attacks, what a second factor stops and what it does not, and why one identity provider speaking OpenID Connect issues the proof the other apps trust.Sessions vs tokens: JWT, refresh & revocation — Every request after a login must carry proof of it. Server sessions and signed tokens such as JWTs carry it differently, and that decides what a logout can take back, and how fast: JWT checks, short access tokens with rotating refresh tokens, revocation, and the local caches a logout must also reach.OAuth 2.0 & OpenID Connect flows — How an app gets limited, revocable access to a user's data at another provider without ever holding their password, how the authorization-code flow keeps that access from being stolen on the way, and what OpenID Connect adds when the app also needs to know who signed in.WebSockets at scale: gateways, routing & draining — Serving many long-lived WebSocket connections: a gateway tier where each connection stays on the instance it reached, a broker or a connection registry to reach a socket held by another instance, sharding by room so one instance owns it, the limits of one instance, and draining on deploy without a reconnect storm.Serverless & edge functions — Code the platform runs for each event, on as many instances as the events need within its limits and, unless you keep some warm, none when they stop: stateless calls, cold starts and how to soften them, concurrency and time limits, a bill per invocation and duration, when a fixed fleet is cheaper, and what changes at the edge.CDN & static delivery — How a CDN serves the same bytes to millions of users from points of presence near them: reaching the nearest edge, the hit ratio and the cache key behind it, an origin shield so misses do not all land on the origin, purges that must reach every edge, versioned URLs, and short-lived dynamic responses at the edge.HTTP caching: Cache-Control, ETags & revalidation — How an HTTP cache decides that a stored response is still fresh, how it checks one that is not with an ETag and a 304, which directives decide who may keep a copy, why Vary is part of the cache key, and when serving a stale copy on purpose is the right answer.Idempotency & exactly-once illusions — Retries at every layer deliver the same operation more than once. What makes an effect safe to repeat, why at-least-once delivery plus idempotent processing stands in for exactly-once, and where that substitute ends: at the edge of your own transaction.Consistency models: strong vs eventual (CAP) — When copies of data disagree, a consistency model says what a read may return. Choose per operation: strong, eventual, or the cheaper guarantees in between, during a partition and on a normal day.Analytics data: OLTP vs OLAP & the warehouse — Why analytical scans do not belong on the transactional database, how columnar storage makes a scan over a few columns cheap and single-row lookups and updates expensive, fact and dimension tables, lake vs warehouse vs lakehouse, and why the warehouse is a derived copy that can be rebuilt from its source.Stream processing: windows, watermarks & state — Computing continuously over a stream with no last event: stateless and stateful operators, tumbling, sliding and session windows, event time vs processing time, watermarks and late data, checkpoints that tie state to input offsets, what exactly-once means inside the processor and end to end, and when a nightly batch is the better tool.Change data capture — How other systems get every committed change to a table, deletes included, by reading the database's own log: why dual writes and polling an updated_at column drift, how a snapshot hands over to the log without a gap, per-key order, idempotent apply under replays, schema changes, what the retained log costs the source, and lag.Schema evolution: event formats & compatibility — Changing an event's shape while old and new versions are in flight: what Avro and Protobuf decide, backward, forward and full compatibility and the deploy order each allows, a registry that refuses breaking versions, and replays.Vector search: embeddings, nearest neighbours & hybrid search — How an embedding turns a query and a product description into vectors where similar meaning lands close, why finding the nearest ones among hundreds of thousands, hundreds of times a second, usually calls for an approximate index such as HNSW or IVF and what it gives up, how metadata filters interact with that index, why the index is tied to the model that embedded it, and why exact identifiers still need keyword results merged in.Model serving: inference, versions & safe rollout — How a trained model becomes predictions a product can rely on: fast enough for the page that waits on it, pinned to a known version, released to real traffic in steps, and watched for the day it quietly goes wrong.The RAG stack: embed, retrieve, rerank — How retrieval-augmented generation answers from a company's own documents: ingesting and chunking them, retrieving wide and reranking down to a few passages, building a prompt with citations, filtering by permission at retrieval time, removing outdated and deleted documents, caching answers by meaning without leaking them, and telling a retrieval failure from a generation failure.Serving LLMs: gateways, fallback & token budgets — The path between an app and the LLMs it calls: one gateway in front of every provider, fallback that keeps the answer usable, versioned prompts checked by evals, per-tenant token budgets, streaming, a trace and a cost for every call, and self-hosting when documents cannot leave.Agent guardrails: checking tool calls & human approval — Why a model's proposed tool call is untrusted input, how prompt injection makes it an authorization problem, what code between the model and the tools checks, failing closed, a person approving the exact call, and what these controls cost and miss.API styles: REST vs GraphQL vs gRPC — Pick an API style by who calls it and how: REST and what HTTP gives it for free, GraphQL queries shaped by the client and what they cost the server, and gRPC between services.Webhooks & third-party integration — A webhook is an HTTP request another system sends you when something happens. Receiving one means verifying its signature, answering fast and processing it so that a second copy or a late arrival does no harm; sending them means signing, retrying with backoff, and keeping one dead endpoint from delaying everyone else's events.Notifications & transactional messaging — Feature code says what happened; one notification service decides who hears about it, on which channel, and whether they have heard enough: preferences and opt-outs, templates, deduplication and per-user caps, a queue per channel so a slow provider holds up no other, retries with a dead-letter path, and delivery status.Email delivery: authentication, bounces & sender reputation — An email provider accepting a message is not a reader receiving it. How a receiving server ties a message to your domain with SPF, DKIM and DMARC, what hard bounces, soft bounces and complaints tell you, and why a newsletter can drag your password resets into the spam folder.Payments & billing integration — Take money through a payment provider: tokenize the card so your servers never see it, follow the payment through its states, take the provider's webhook as the result, ask the provider when the webhook is late, and reconcile your records against the provider's.Debt simplification: netting a group's balances — How a group's tangle of pairwise debts reduces to one net position per member, why a greedy settle-up never needs more than one transfer fewer than the number of members while the true minimum is a hard search, how to split cents without losing one, and why the settle-up plan is derived from the expense records instead of stored.Rendering strategies: SSR, SSG, CSR & the edge — Where and when a page's HTML is built (in the browser, on a server for each request, ahead of time, or near the reader) and what each choice costs in hydration, freshness, caching and link previews.Micro-frontends: one page, many teams — How one web front end is split into slices that separate teams build, deploy and own, then composed back into one page: the shell, where composition happens, versioned releases a team ships and rolls back alone, a broken slice that leaves the page standing, shared design tokens, thin channels between slices, and when one app is still the better choice.Containers & orchestration — Package a service with everything above the kernel into an image, name it by digest, and let an orchestrator keep the declared number of copies running: placed by requests, capped by limits, checked by probes, replaced by rolling updates.Sandboxing untrusted code: isolation, limits & egress — Running code you did not write without letting it reach anything it should not: resource limits and the verdict each one produces, the layers of the boundary (an unprivileged process, a container sharing the host kernel, a user-space kernel, a microVM, language isolates) and what each costs, no network and no credentials inside, a fresh sandbox per submission, defence in depth, and what no sandbox promises.CI/CD pipelines: integrate, build once, promote — Merge small changes often and build and test every one, stop the line when main is red, build the artifact once and promote that same digest through every environment, keep the pipeline as code with gates between stages, and choose between continuous delivery and continuous deployment.Software supply chain: signing, provenance & scanning — What you run is the end of a chain of code you did not write and steps you did not watch. Pin what goes in, build it clean, sign what comes out and verify the signature where it runs, record how each artifact was built and what it contains, and keep in mind what a signature and a clean scan do not prove.Infrastructure as code — Declare your cloud resources in versioned files: compare desired state with what exists, read the plan before you apply it, keep the state file shared and locked, catch drift from changes made by hand, and keep environments alike with shared modules.Scheduled jobs & cron — Run work on a clock with cron or a scheduler service, and handle what goes wrong around each firing: runs missed while the machine was down, a run still going when the next one starts, a job that fires twice, several scheduler nodes, and a job that silently stops firing.Durable workflows: orchestration that survives restarts — Multi-step processes that outlive crashes, deploys and days of waiting: progress persisted outside the process, recovery by replaying an event history or reading saved state, steps that can run more than once and must be idempotent, per-step retries, durable timers and signals, determinism and versioning for replay engines, run visibility, and when a queue plus a status table is enough.Time zones, DST & recurring events — Why a weekly 10:00 meeting is a local time in a named zone, not a UTC timestamp: instants vs wall-clock intent, IANA zones as rule sets that change by law, the DST gap and overlap, storing an RRULE and expanding it per window, editing one occurrence vs the series, and computing the next reminder.DNS, proxies & the network edge — How a name becomes an address: the resolvers and caches between a client and your authoritative servers, TTL as the trade between query load and how fast a change lands, cached failures, answers steered by location and health, and the reverse proxy the request reaches next.Network protocols: TCP, UDP, HTTP/2 & HTTP/3 — What a request pays in round trips before its first byte, and what one lost packet costs, from TCP and TLS handshakes through HTTP/2 to HTTP/3 over QUIC, with TCP kept as the fallback.Edge protection: WAF, DDoS & defence in depth — What stands between the internet and your application: what a WAF filters, what it cannot see and whom it blocks by mistake, why a volumetric flood is absorbed by the edge network while an application-layer flood looks like real users, and why each layer is built expecting the one before it to miss something.Web application security: injection, XSS, CSRF & SSRF — Four classic flaws share one cause: outside input reaches something that interprets it, or acts with privileges the sender lacks. Parameterized queries, contextual output encoding, SameSite cookies with anti-CSRF tokens, and checks on the address actually fetched each fix one at the root, and each has limits.Backups, high availability & disaster recovery — Why a standby replica does not protect your data, how RPO and RTO set the design, full, incremental and snapshot backups, point-in-time restore from an archived log, backups an attacker inside production cannot delete, restore drills, and losing a whole region.Feature flag services: targeting, rollouts & kill switches — How a flag service gets a rule change onto every server in seconds and decides, per user and without a network call, who sees a feature.A/B testing & experimentation — How to find out whether a change made things better, by splitting users at random between two versions and reading one metric carefully enough to trust the answer.Coordination services: small state, leases & watches — What belongs in etcd, ZooKeeper or Consul and what does not: leases that delete keys when their holder dies, writes that succeed only if nothing changed, watches, revisions that double as fencing tokens, why the service stays off the request path, and how to run it.Consensus — How a few replicas agree on one ordered log of decisions while some of them crash: why a majority and not everyone, why clusters run three or five nodes, how a leader commits an entry, how terms shut out a deposed leader, and where the guarantee ends.The BFF tier: gateway, sessions & fan-out — A Backend for Frontend running in a real system: where it sits behind the API gateway, why it is where a browser's session is held, how it calls five services for one page without letting a slow optional part hold the page, what it caches, and what one more deployable per experience costs.ETL/ELT & data orchestration — How data gets from operational systems into the warehouse and stays trustworthy: ETL vs ELT and why the order matters, full vs incremental loads from a high-water mark or CDC, orchestration as a DAG of tasks with dependencies, retries and schedules, quality checks before a table is published, and freshness checks that catch the run that never happened.Batch processing: partitions, shuffles & backfills — How a job over a finished, bounded input runs on many machines: input partitions and map tasks, the shuffle that brings every record of a key together and why it costs the most, skew and stragglers, retries that are safe only for deterministic tasks with atomic output, output partitions replaced instead of appended, backfills over historical days, and when batch beats a stream.GPU & accelerated compute — Why model training and inference run on GPUs and other accelerators, why memory and batching decide how much work one device does, how latency limits that batching, how to scale a GPU pool whose new machines take minutes to arrive, and what one request really costs on it.Feature stores: online, offline & training-serving skew — How a feature store helps keep the values a model trains on and the values it sees in production the same, so that a model does not quietly score worse live than in its evaluation.Recommendation systems: retrieval, ranking & cold start — How a recommender narrows millions of items to the few dozen one user sees, and what it does for users and items that have no history yet.Configuration management — Tell configuration apart from code, secrets and feature flags, layer it so you know which value wins, check it against a schema when it loads, and treat every config change as a deploy that is versioned, staged and easy to roll back.Data governance: catalogs, lineage & classification — Why two correct dashboards can disagree, and what a data catalog records to settle it: owners, certified datasets, lineage traced upstream and downstream, sensitivity tags that drive masking and grants, and the retention rules those tags feed.Deleting a person's data: erasure across every copy — Why a delete button removes one copy of a person and the rest stay: listing every store and every key the person lives under, a resumable fan-out with its own order, derived copies that refill themselves, backups and archives that cannot drop a row (expiry with a deletion log replayed after restore, or crypto-shredding and its limits), what the law lets you keep, outside providers, and a completion record that holds none of the erased data.Network topology: VPCs, NAT, VPN & bastions — Lay out a private network so the internet reaches only the load balancer: public and private subnets, route tables, security groups and network ACLs, outbound calls through NAT with egress filtering, VPN and peering scoped to what is needed, and operator access without an open SSH port.Media processing & transcoding — Turning an uploaded photo or clip into the files every client needs, off the request: a job queue, checks before anything is decoded or published, renditions made in parallel, an asset marked ready only when every output exists, workers that may run a job twice, files that fail every attempt, and what the compute costs.Approaching a system design problem — What to do with a blank canvas: six questions in a fixed order, from requirements and estimation through data ownership, read and write paths and failures to trade-offs, what each answer hands to the next question, and when to go back a step.Back-of-envelope estimation — Rough, checkable arithmetic that turns daily users into requests a second, peak load, storage a year, bandwidth, a cache's working set and a server count with headroom, and tells you which parts of a design need to scale.Cache eviction: TTL, LRU, LFU — A full cache drops something on every insert. TTL and size-based eviction answer different questions, LRU and LFU each fail in a recognisable way (a scan that flushes the cache, a popularity that never fades), and real caches approximate and combine them.Hot keys & cache stampedes — When one hot key expires, every request that misses at the same moment goes off to recompute it. How coalescing, a shared lock, stale-while-revalidate and early refresh hold the database to one recompute or close to it, and what to do when a key is too hot for a single cache node.Consistent hashing — Distribute keys across nodes so that adding or removing a node moves only ~1/N of the keys, not nearly all of them: why hash mod N reshuffles, the ring, virtual nodes, replicas along the ring, and how fixed slots and rendezvous hashing keep the same promise.Fan-out: push vs pull — One event, many receivers: precompute each receiver's copy when the event happens (push), assemble each view when it is read (pull), or split by audience size, and what each choice costs for quiet receivers, unfollows and withdrawn events.Regional routing & geo-partitioning — Send each request to a nearby region, give every account a home region its data never leaves, decide what may cross between regions, and keep the residency promise when a region fails.Data structures behind big systems — A store is fast at what its internal structure makes cheap. One logging platform meets the LSM tree, the Bloom filter, the inverted index and HyperLogLog, and each buys its speed or its small size by giving something up: read cost, write cost or exactness.Geospatial indexing & proximity search — "What's near me?" needs a spatial index: cells such as geohash, S2 or H3 turn a 2D radius into a few 1D lookups. Why one cell is never enough, how moving objects change cells, and what to do when one cell gets crowded.Route planning on road graphs — How a maps service finds the fastest way between two points on a road network with millions of junctions: the road graph and its travel-time weights, why Dijkstra's algorithm is exact but far too slow at scale, aiming the search, shortcuts computed ahead of time, keeping them correct under live traffic, snapping a GPS point to a road, and why an ETA is only as good as its weights.Presence & ephemeral state — Online dots, typing indicators and live cursors are state that must expire by itself: heartbeats and a TTL, why a goodbye cannot be trusted, what turns an expired key into an offline event, keeping "online now" apart from "last seen", telling only the users who are watching, a grace period against flapping, presence across several devices, and typing and cursor updates that are throttled and allowed to be lost.High-write ingestion — Absorbing a write rate far above the read rate: a log in front of storage, batched writes, partition keys and hot keys, stores built for appends, expiry and downsampling, and deciding in advance which data may be lost.Counting at scale — Why a busy counter loses updates or queues on one row, and how atomic increments, sharded counters, write combining and a replayable log keep it correct and fast, with a fast approximate count beside an exact one.Worked design: a link shortener — The whole design loop on one system: estimate, key generation, the redirect read path (301 vs 302), and click counting.Worked design: a realtime chat — One chat system end to end: the estimate, dumb gateways with a registry and a bus, a per-conversation sequence from one authority, persist then push, offline push off the bus, and what end-to-end encryption would change.Worked design: matching riders to drivers — A location firehose, proximity matching, and an offer state machine — the three hard problems of dispatch.Transactions & isolation levels — What a transaction actually promises, the three read anomalies plus the lost update and write skew, and when SERIALIZABLE is worth its price versus a conditional update.Two-phase commit — How a coordinator makes several databases commit one transaction all or nothing: a vote, a logged decision, the in-doubt participant that must wait, and why the protocol blocks when the coordinator fails.Indexing & query optimisation — Index the access pattern, not the column: B-tree, hash, composite, covering, partial and expression indexes, what each one adds to every write, and how to read the plan that says whether it worked.N+1 queries: lazy loading, joins & batching — Why a page that fetches a list once and then reaches back to the database for every row sends N+1 queries, what the extra round trips cost, how to catch them in logs and tests, and the fixes with their trade-offs: a join, a second query by ids, a grouped count, batching per request, and not loading everything.Pagination: offset, keyset & cursors — Why a list API hands out one page at a time, why OFFSET repeats and skips rows while the list changes and slows down on deep pages, how keyset pagination continues after the last row with a unique tie-breaker and a matching index, what an opaque cursor should hold, what keyset gives up, and what no cursor can promise when the sort key is a live vote count.Trees in SQL: adjacency lists, paths & closure tables — Storing a tree in flat tables: a parent_id adjacency list walked by a recursive CTE and guarded against cycles, a materialized path read by prefix, a closure table with a row per ancestor, and what each costs on a move.Unique ID generation — Why auto-increment stops scaling, ranges handed out by one counter, random vs time-ordered IDs (UUIDv4, UUIDv7, ULID, Snowflake), leased worker ids, the clock-skew trap, and what an ID gives away.Single-writer sequencing & matching engines — Why an order book gets one writer and a sequenced log instead of locks: price-time priority makes arrival order the result, a sequencer numbers each order and makes it durable before it is matched, a deterministic engine rebuilds the same book from a snapshot and the log, a standby reads the same log, and what one writer per symbol costs.Distributed locks & leader election — Lease-based locks with TTLs, why a lock alone can't protect the resource, fencing tokens, and single-writer patterns that avoid taking a lock per job.Schema migrations without downtime — Changing a table that never stops taking writes: expand, migrate and contract across deploys, dual writes, batched backfills, online index builds, code that tolerates both shapes, and the small statements that lock a table.API versioning & backwards compatibility — Change an API that apps already depend on without breaking them: which changes break a client, why tolerant clients are not enough, where the version lives, translating old versions at the edge, and retiring one when the last callers run on phones nobody updates.Multi-tenancy — Serving many customers from one system: how much to share, keeping every query inside its tenant, stopping one tenant from slowing the rest, carrying the tenant through caches, queues and jobs, and giving a large tenant capacity of its own.Backpressure & load shedding — Why a system a little over capacity can end up serving almost nobody, and how it stays useful: a bound on every buffer, producers slowed where they can wait, work refused at the edge where they cannot, deadlines that travel with the request and retries kept on a budget.Virtual waiting rooms: admitting a crowd fairly — What to do when far more people arrive for an on-sale than the checkout can serve: hold them in a visible line in front of the site, let them in at the pace the checkout can finish, check a signed admission token so nobody skips the line, choose who stands first, and tell people honestly where they stand, including when the seats are gone.SLOs & error budgets — Turn "reliable" into a number you can measure, alert on and spend: SLIs, SLOs, the budget they imply, and burn-rate alerts that page on the trend rather than the blip.Latency percentiles & tail latency — Why an average response time can describe almost no request, how to read p50, p90 and p99 off a sorted list, why a request that waits on 100 backends inherits their slowest 1% most of the time, why percentiles cannot be averaged across hosts or minutes, and what shortens the tail.Progressive delivery: blue-green, canary & rollback — Separate deploying a version from releasing it: expose the new version in steps that each have a way back, choose between blue-green, canary and feature flags, let the metrics trigger the rollback, and keep the database working for both versions while they run side by side.Secrets management & encryption — Where keys and credentials live, how data is encrypted at rest and in transit without every service holding the master key, and how rotation stops being an event.End-to-end encryption: keys on devices, a server that can't read — Encryption where only the users' devices hold the keys, so the server routes and stores what it cannot read: a key pair per device and a directory of public keys, one ciphertext per device, safety numbers and key-change warnings, forward secrecy and group keys, new devices and history, attachments and content-free pushes, and what the server can no longer do, metadata included.Top-K & leaderboards — Answering a player's "what is my rank?" among 30 million: why an index makes the top 10 cheap and a rank expensive, sorted sets that keep the order on every write, ties, time windows, merging per-shard answers, and count-min sketches for global heavy hitters over a stream.Typeahead & autocomplete — Suggestions that keep up with typing, about 100 ms per request: a precomputed top-N list per prefix, a client that debounces and cancels, hot prefixes cached at the edge, and lists rebuilt from the query log and swapped in whole.Graph databases — When the shape of the connections is the query: why a variable-length path hurts in SQL, index-free adjacency and the property graph, hop limits and supernodes, the graph as a side index fed from the system of record, and when a key-value adjacency list is all the graph you need.Large file upload — Getting an 8 GB file into object storage without it passing through your servers: presigned URLs that pin what was approved, multipart uploads with per-part checksums, sessions that resume, a quarantine bucket, completion learned from a storage event, and expiring what never finishes.Realtime transport: long-polling vs SSE vs WebSocket — Three ways to push to a browser, chosen by which way the messages flow and how often: proxies that buffer, idle timeouts and heartbeats, how each transport resumes after a drop, and the fallback ladder that keeps one event stream behind all three.Realtime media: WebRTC, SFUs & NAT traversal — How live audio and video reach several people fast enough to hold a conversation: media over UDP instead of the app's WebSocket, signaling the app supplies, ICE with STUN and TURN to get through NATs, why a call outgrows a mesh into an SFU, simulcast and bandwidth estimation per receiver, one meeting per SFU or a cascade, and recording off the live path.Multiplayer game state: authoritative servers & tick rates — Keeping one fast-changing world the same for every player over a laggy network: a server that runs the only simulation that counts, inputs instead of results, fixed ticks, client-side prediction and reconciliation, entity interpolation, lag compensation, deltas and interest management, the match held by one process, and lockstep as the alternative.Worked design: a news feed — A social feed designed end to end: the estimate, IDs in the feed and posts in one place, precomputed feeds with a celebrity cutoff, a read path that merges, ranks and hydrates, cursor paging, and the caches that matter.Worked design: a web crawler — A crawler designed from the morning a site blocked it: per-host queues paced by a politeness scheduler, a fetcher pool on leases, cached robots.txt and DNS, URL and content dedup, revisit timing, and the traps that grow the frontier without end.Worked design: hotel booking — Inventory per room type per night, a conditional update that decides the race for the last room, a hold with a TTL, payment outside the transaction, a conditional confirm and an expiry sweeper: correctness over scale.Worked design: video streaming — Upload to object storage, a transcode pipeline cut into per-rendition chunks, adaptive-bitrate manifests behind a CDN, and view counting off the hot path.Worked design: a digital wallet — An append-only double-entry ledger, idempotent transfers in one short transaction, balances as a derived view with a conditional overdraft check, hot accounts and reconciliation: moving money without creating or losing any.Content moderation at scale — How a platform screens what users post: classifier scores split into three lanes per category, the uncertain kept hidden where exposure is costly, text and image verdicts combined, a human queue ordered by harm and bounded in time, and appeals and audits that measure wrong removals and missed violations and feed the models.Ad serving & real-time auctions — Pick a winning ad inside a 50 ms budget: what each stage returns when its slice runs out, candidate retrieval, ranking on fresh features, the auction's pricing rule, and budget caps that hold across a distributed fleet.Usage metering & billing pipelines — Turning raw product usage into an invoice finance will sign: usage events with stable ids, deduplication, totals per customer, meter and period, late events and closed periods, rating against the plan, and reconciliation before the invoice goes out.Authorization: roles, relationships & policies — Who may do what, answered in single-digit milliseconds: RBAC vs ReBAC vs ABAC, the list-what-I-can-see problem, and how a revocation propagates.Audit logs & tamper evidence — What an audit record must hold, capturing it so no change skips it, storage the audited people cannot write to, hash chains anchored outside the store and what they prove, retention against erasure, and answering an auditor years later.Servers, not utilization, decide the queue — Why waiting explodes as a server nears 100% busy, why 30 servers at 90% barely queue while one server at 90% waits nine times its service time, why one shared line beats four separate ones, and what that means for headroom and autoscaling targets.Pattern building blocks (generic roles) — The Generic Roles section of the pattern palette: Actor, Service, Handler, Event and twelve more neutral participants for sketching any pattern by who does what, each renamed for the job it plays.Factory Method — Let a base class do the shared work while each subclass decides which concrete object to create, so the base only ever names an interface and a new variant is a new subclass rather than an edit.Abstract Factory — Create families of related objects that must be used together through one factory interface, so the client never names a concrete class and one choice gives it a matched set, at the price of changing every factory when a new kind of product arrives.Builder — Assemble a complex object one named step at a time, so no caller faces a constructor full of nulls and the same steps can produce different representations.Singleton — Keep exactly one instance of a class with one global point of access to it, and know the price: a dependency no signature shows, state every caller shares, tests that leak into each other, and a first call that needs care when threads race.Prototype — Build one fully configured object, then make new ones by asking it to clone itself: what to copy, what to share, what to reset, and how a registry lets new types arrive without changing the caller.Adapter — Make an existing class usable through the interface a client already expects, with every translation, including units, error values and exceptions, kept in one wrapper, and choose between an object adapter and a class adapter.Bridge — Split a design that would need one class per combination into two hierarchies, an abstraction and an implementation, joined by a reference instead of inheritance so each side grows on its own.Composite — Give a single part and a group of parts one interface, so code that asks a question of a whole tree gets its answer by recursion without checking what each node is, and decide deliberately where the methods that add and remove children live.Decorator — Add a responsibility to an object by wrapping it in another object with the same interface, so features stack in any combination at runtime instead of multiplying subclasses.Facade — Give the clients of a subsystem one smaller interface that knows which parts to call and in what order, without taking direct access away from the code that needs it.Proxy — A stand-in that implements the same interface as the real object and decides whether, when and how a call reaches it, for lazy loading, access checks, caching or a remote call, though that transparency has limits.Flyweight — Share the immutable state that many fine-grained objects have in common, pass the rest in from outside, and check that the count and the size make the saving real.Observer — A subject keeps a list of observers and notifies each of them through one small interface, so new observers arrive without changes to the subject, and the price of that freedom shows up in slow observers, out-of-order changes and listeners nobody removed.Strategy — Put each interchangeable algorithm behind one interface, so the code that uses it stops branching on which one it has, and the choice can change at runtime.Null Object — Replace the null checks every caller repeats with an implementation of the same interface that does nothing or returns a neutral value, and know when that silence hides a real problem.Command — How turning a request into an object lets an app queue, log and undo it, and what undo must keep when an operation has no exact inverse.Mediator — Centralize how a set of objects interact so they don't reference each other directly, and keep the hub that holds the rules from growing into the next tangle.State — Let an object change its behavior when its internal state changes, by delegating to one object per state, and decide who owns the moves from one state to the next.Chain of Responsibility — Pass a request along a line of handlers, each of which either deals with it or hands it to the next, so the sender never has to know which one will act, and decide on purpose what happens when none does.Iterator — Walk a collection one element at a time without knowing how it is stored. Each iterator keeps its own position, so two traversals can run at once, and a good one says what happens when the collection changes during the walk.Visitor — Add new operations over a stable set of element types without editing them, through accept, visit and double dispatch, and know the price when a new element type arrives.Memento — Capture an object's internal state in a token only that object reads back, so other code can keep it and restore it later without seeing inside, and know what copying the whole state costs.Template Method — Write an algorithm's order of steps once in a base class, let subclasses supply the steps that differ, and know what that inheritance costs.Bounded Context — Why one model stretched across teams who mean different things by the same word swells and breaks, and how to choose the boundary in the software inside which one model and one language hold.Subdomains & ubiquitous language — Strategic DDD starts with what the business does: core, supporting and generic subdomains decide where the best effort goes, a precise language built with the domain experts runs from conversation into code and tests, and a word that means two things to two groups of experts signals where to look for a boundary.Aggregate — A consistency boundary: a cluster of entities and value objects changed together through one root, which enforces the rules that must hold after every change, referenced from outside only by id, and sized so those rules stay inside it without every change contending for it.Entity — A domain object defined by a stable identity over time, not by its attributes: equality by id, where that id comes from, and why it must outlive every change of name, address and status.Value Object — Why bare numbers and strings let kilograms be compared with pounds, and how a value object fixes it: an object with no identity, equal to any other with the same values, immutable so operations return new values, and valid from its constructor, plus how the same concept can be a value in one model and an entity in another.Domain Event — A past-tense business fact that an aggregate records once its own state has changed: what the event carries, why the aggregate collects events instead of calling its listeners, whether in-process handlers run before or after the commit, and how a domain event differs from the integration event other services receive.Repository — Why domain code that talks to tables is slow to test and easy to bypass, and how a repository gives it collection-like access to whole aggregates: one per aggregate rather than per table, its interface in the domain and its implementation in infrastructure, why screen queries do not belong on it, and how an in-memory version tests a use case without a database.Active Record vs Data Mapper — Who knows how to load and save a domain object: the object itself, wrapping its row, or a separate mapper that keeps objects and tables apart. What each costs, when each fits, and the mapping problems a mapper brings with it.CQRS — Give changes and questions separate models: a write model that enforces the rules, read models shaped for each screen, and the staleness that follows when events update those read models asynchronously.Event Sourcing — Record every change as an immutable event and derive current state by replaying them: streams, appends that check the expected version, projections for reads, and events whose shape outlives the code that wrote them.Event Bus — One shared routing point that every module publishes to and subscribes through: a registry of handlers by event type, what an in-process bus does and does not promise when a handler throws or the process dies, what changes when a broker sits underneath, and why the registry is worth reading.Publish / Subscribe — The publisher announces a fact to a topic and never names who receives it, so subscribers can come and go without changing it. In exchange, the publisher cannot tell who acted on a message, cannot get a reply or wait for subscribers, and cannot see which of its fields they depend on.Saga — Keep data consistent across services without a distributed transaction: each step commits locally, compensations semantically undo the completed steps in reverse order, the irreversible step goes late, and other requests can see the half-finished state.Compensating Action — The new business operation that cancels the effect of a step already committed: rarely the step's mirror, amends where no real undo exists, safe to run twice, and handed to a person when it cannot succeed.Layered architecture — Organize code into horizontal layers by technical job, with every dependency pointing down: what strict and relaxed layering allow, when a layer that only passes calls along is worth keeping, and the cost at the bottom of the stack, a domain that depends on the database code.Hexagonal (Ports & Adapters) — Put the application core at the centre and let it reach the outside world only through ports it defines: driving ports the outside calls, driven ports the core needs, and adapters on the outside that connect each port to a real technology, so a test or a second provider needs a different adapter that honours the same port, not a change to the core.Anti-Corruption Layer — How a translation layer at the edge of your context keeps a foreign or legacy model out of your domain, in both directions when you write back, and what it costs to own.Sidecar — Run a helper process in the same deployment unit as a service, sharing its lifecycle, its network and its volumes: what moving a job out of process buys, what it costs on every instance, and why start and stop order matter.Circuit Breaker — Stop calling a dependency that recent calls show is failing: how the breaker trips on a failure rate, fails fast while open, and lets a few trial calls decide when to close again.Object Pool — Keep a capped set of expensive objects, such as database connections, and lend each to one borrower at a time: create on demand up to the cap, reset before reuse, always give it back.Dependency Injection — Hand an object the collaborators it needs instead of letting it build them, so a test, an environment or a new implementation changes the wiring and never the object.Interpreter — Represent each rule of a small language as a class, build each sentence as a tree of those objects, and evaluate it by calling interpret(context) on the root. Parsing the text is a separate job, and large grammars or hot paths call for a parser generator or a dedicated engine.Domain Service — Where to put a business operation that belongs to no single entity or value object: a stateless service in the domain layer, named in the business's language, that takes domain objects and leaves each aggregate to guard its own rules. Why calling it does not make two aggregate changes atomic, and how a model turns anemic when every method moves into a service.Factory (DDD) — When a constructor is enough and when it is not: a factory creates a whole aggregate valid from birth when creation needs rules or other objects, as a method on an existing object or a factory of its own, and loading the aggregate from storage later is reconstitution, which does not run the creation rules again.Specification — A business rule written once, as an object that answers whether a candidate satisfies it, combined with and, or and not, and reused to validate one object, filter a loaded list and build a database query. Where the query use stops: not every rule translates to SQL, and the object and its query are two implementations that can drift.Unit of Work — Why a use case that writes as it goes can leave half its changes in the database, and how a unit of work records what was added, changed and removed, then lets the application service commit it all in one transaction: the order of the writes, version checks at commit, and why it lives for one request and one database.Transactional Outbox — Write the business change and the message about it in one local transaction, then let a relay publish the message: polling the table or reading the database's log, at-least-once delivery, and why consumers must deduplicate.Idempotent Consumer — Make a message handler safe to run more than once for the same message: record the id it applied in the same transaction as the effect, so a redelivery changes nothing. Which id to record, how long to keep it, and what to do with effects that cannot join that transaction.Process Manager — One stateful coordinator instance per running process: correlate each incoming event to its instance, keep that instance's state durably, decide the next command from it, and set a deadline for the event that may never come.Pipes and Filters — Split a processing job into filters that each make one transformation and pass a message through pipes to the next, so steps can be reordered, reused or given more instances, held together by the message format they share.Content-Based Router — One component reads each message and sends it to exactly one destination chosen from its content, so the routing rules live in one place instead of in every sender, and that one place has to know every destination.Message Translator — Two systems describe the same fact in different shapes, and a Message Translator converts each message from the sender's format into the receiver's so that neither has to change its own model. The syntax is the easy part; the hard part is the decisions hidden in the mapping.Message Filter — A step in the flow with one output: it passes the messages that match a predicate and drops the rest, so a consumer sees only what it acts on. Where to filter, and why dropped messages need counting.Selective Consumer — A consumer tells the messaging system which messages it wants, as a condition on their headers or properties, and the rest stay on the channel for other consumers: a fit for a mixed channel, as long as every message has someone who selects it.Splitter — Break one composite message into one message per part, each carrying what it needs to be handled alone and the ids that let the parts be gathered again, so one bad part fails by itself instead of taking the whole message with it.Aggregator — A stateful step that collects related messages by a correlation id and emits one combined message when a completion condition, chosen before the first part arrives, says the group is done, including the group whose last part never comes.Scatter-Gather — Send one request to several responders at once and return one answer by a deadline taken from the caller's own time budget: the best of whatever came back, labelled as partial when it is, at the cost of asking several responders every time.Routing Slip — Decide a message's route once, when it enters, and attach it to the message as an ordered list of steps; each step does its work and forwards the message to the next one on the list, with no central router. What goes wrong mid-route, and when a fixed list stops being enough.Normalizer — The same fact arrives from several sources in several formats; a Normalizer recognises each message's format, sends it to the translator for that format, and lets one canonical format leave, so N sources and M consumers need at most N + M mappings instead of up to N × M.Dead Letter Channel — After a bounded number of attempts, move a message that cannot be delivered or processed to a separate channel, with the reason it failed, so the queue keeps moving and the message can be fixed and replayed.Control Bus — A separate channel for messages about the integration itself: commands, queries and events that let operators pause, reroute, replay or question message-driven components while they run, without an admin API in each one.Message Channel — A named address that a sender writes to and receivers read from, so neither has to know the other: usually one kind of message per channel, and a deliberate choice between giving each message to one receiver or to every subscriber.Command, Document & Event Messages — Every message carries an intent: a command asks one receiver to act and can be refused, an event announces a fact that any number of receivers may react to, and a document hands data over. The kind decides the name, who owns the contract and what a failure means, and the broker does not enforce it.Guaranteed Delivery — Each hop acknowledges a message only after it is stored durably, by that hop or the next, and the hop before keeps its copy until then, so a crash does not lose it. It is only as durable as each hop's storage and replication, it arrives at least once rather than exactly once, and each send pays for it in latency.Transactional Client — A messaging client that does its receive and its sends inside the messaging system's own transaction, so they commit or roll back together: what that covers inside the broker, what it leaves outside (a database write, a call to another service), and what each commit costs.Messaging Bridge — When two separate messaging systems both have to stay, a bridge consumes from channels on one and republishes on the other. It decides which channels cross, acknowledges a message only after the other side has it, and has to keep order where the flow needs it, avoid loops and leave each side working while it is down.Ambassador — A sidecar that proxies an app's outbound calls: the app talks plain HTTP to a local port, and the ambassador adds TLS, timeouts, retries and metrics on the way out. Strongest when the app cannot be changed, and full of traps when its retries meet the app's own.Asynchronous Request-Reply — When work outlasts an HTTP request: answer 202 Accepted with a status URL, let the client poll or be called back, and handle the retried POST, the lost status and the job that never finishes.Bulkhead — Give each dependency its own limited share of threads or connections, so one slow dependency fills only its own compartment, where further calls are refused fast, while everything else keeps serving.Cache-Aside — The application owns the cache: check it, load from the database on a miss and fill it, and on a write update the database and then delete the key. Why deleting beats overwriting, the race that can still put an old value back, and what bounds it.Choreography — Advance a multi-service workflow by having each service react to the others' events, with no coordinator: what that makes easy, why the flow itself has no single home, how to find one stuck instance, how event chains loop, and when part of the flow should move to a coordinator.Claim-Check — A payload too large or too sensitive for the channel waits in a store, and the message carries only a reference that each receiver redeems. The hard questions then move to the store: which write comes first, who may read it, and how long it keeps each payload.Competing Consumers — Several workers take messages from one queue and the broker gives each message to one of them: throughput scales out, at the price of redeliveries, lost ordering and poison messages.Compute Resource Consolidation — Run several workloads on shared compute so the capacity one leaves idle serves another. When their peaks fall at different times, the combined peak is smaller than the sum of the separate peaks; the price is noisy neighbours, shared failures and a shared security boundary, so the real decision is which workloads share.Deployment Stamps — Run several complete, independent copies of the stack, each with its own data and its own group of tenants, so capacity grows by adding copies and a bad release or a failing dependency inside one copy can be kept from reaching the others.Edge Workload Configuration — Publishing a configuration does not mean a fleet runs it. When devices are many, often offline and not all alike, the control plane has to track what each one should run and what it reports, target cohorts by model, firmware and region, let devices catch up after days away, and widen a rollout only while the reports stay good.External Configuration Store — Move configuration out of each deployment into one shared, versioned store that every instance reads: how instances learn of a change, what they run on when the store is down, how they apply a whole version at once, and who may change which keys.Federated Identity — Accept a sign-in performed by an identity provider someone else runs: route each user to the right provider, keep a trust configuration per provider, map its claims to your own user record, link accounts safely, and decide what happens when the partner removes someone.Gatekeeper — Split the host that faces the internet from the host that holds the secrets: a hardened gatekeeper with no credentials for the data or the services behind it validates and sanitises each request and forwards it over one narrow path to a trusted host with no public address.Gateway Aggregation — One endpoint at a shared gateway that calls several services and returns one answer, and how to keep that answer on time when a service is slow, with any missing part marked as missing.Gateway Offloading — Move the work every service does the same way, and that needs no knowledge of the domain, into the gateway: which concerns qualify, how a check done at the gateway reaches the services, the network rule that keeps it honest, where TLS ends, and what the services still decide.Gateway Routing — One address for clients and a table of rules behind it: what a rule can match, which rule wins when two match, rewriting the path on the way, and moving a backend without changing any client.Geode — Run identical deployments in several regions, each able to serve any user's request, and route every user to the nearest healthy one. The hard part is a data layer every region can read and write: replication lag, conflicting writes, and what the loss of a region takes with it.Health Endpoint Monitoring — What a health endpoint should test and what the platform does with the answer: liveness restarts a process, readiness stops routing to it, a startup check buys a slow start time. Why a check on a shared dependency can take every replica out at once, how thresholds and flapping play out, and why probing from outside asks a different question.Index Table — A table the application maintains, keyed by the field you need to query and pointing back to the data, for stores that only look up by primary key or data sharded by another key: keeping it in step in one transaction or from a change feed with retries and reconciliation, what a reader sees while it lags, pointers versus copied columns, and a unique field.Leader Election — Let one of many identical instances run the work that must not run twice, and move that job when it fails: candidates racing for one lease, the gap with no leader and the TTL that sets it, what a new leader does first, and handing over on purpose.Materialized View — Store a query's result in the shape readers need and keep it up to date from the source of truth: refreshed in the database, on a schedule or from each change, telling readers how fresh it is, and rebuilt from the source when it drifts.Priority Queue — Let urgent work overtake routine work that is waiting: native priorities or one queue per class, how to keep low priority from starving, why a message a worker already holds is not overtaken, and who gets to set the priority.Quarantine — Hold a third-party package, a partner's file or an upload where nothing can use it while checks run, then promote exactly the bytes that passed to the trusted area, or reject them with a reason.Retry — Make a failed call again, automatically: which failures are worth another attempt, how long to wait between attempts (exponential backoff with jitter), how many to allow, and how retries at several layers multiply into a retry storm.Scheduler Agent Supervisor — Drive a multi-step operation across remote services with a Scheduler that records each step's state and deadline in a durable store, Agents that wrap each remote call, and a Supervisor that sweeps the store for failed or overdue steps and asks the Scheduler to retry or compensate.Sequential Convoy — Process related messages in order while still processing unrelated ones in parallel: choosing the group key, hashed partitions or session-enabled lanes, what one worker per group caps, and what stays unordered between groups.Shard routing and the shard map — Where the decision from key to shard is made (in a client library, a proxy tier or a directory service), a computed map versus a lookup directory that moves one tenant by changing one row, how routers learn that the map changed, why a shard must refuse keys it no longer owns, and the router as one more hop that can fail.Static Content Hosting — Serve the files that are the same for every user from object storage behind a CDN, so the app servers handle only the requests that depend on who is asking or on current data.Strangler Fig — Replace a legacy system one capability at a time behind a facade that sends each request to the old or the new code: where to cut first, who owns the data while both systems run, proving a slice before the flip, and the migration that stalls halfway.Throttling — Meter what each consumer's work costs a shared resource and, as one nears its budget, delay or degrade that consumer's work, or refuse it with a Retry-After the server can stand behind, so one tenant cannot take capacity everyone shares.Valet Key — Let a client reach one resource directly with a key your service signs after its own checks: what the key pins (the object, the operation, size and type where the store supports it, the expiry), why the bytes skip your servers, why a leaked link works until it expires, and why what arrives still has to be checked.Conformist — The decision to adopt an upstream model as-is instead of translating it: a deliberate trade-off when that model is good enough, you have no leverage and translation would cost more than the coupling; what it costs, how far it should reach, and when to switch to an Anti-Corruption Layer.Published Language — A documented, shared format for the data that crosses a boundary, so consumers depend on it instead of on another context's internal model: who owns it, how it changes without breaking them, and what it costs.Context map: how bounded contexts relate — Once a business runs on several bounded contexts, a context map records who is upstream of whom and whose model wins at each seam, each relationship a choice with a cost, drawn as it is and redrawn when it changes.Snapshot — Save an event-sourced aggregate's state with the version it covers, so a rebuild loads it and replays only the later events: a disposable cache, with a cadence to tune and a format that can go stale.Poison Pill — A message that is well-formed but makes its consumer fail every time it is handled, and how to recognise it, count its attempts somewhere a crash cannot erase, and divert it before it freezes everything queued behind it.Message Deduplication — A filter that remembers each message's own producer-assigned id for a window of time and drops later copies with the same id: where it can live, how long the window must be, why the check and the record must be one step, why a content hash or a correlation id makes a poor key, and what the filter cannot see.Database per Service — One service is the only reader and writer of its tables: what that buys, what it takes away (the cross-service join, the cross-service transaction, shared reference data), how each comes back through API composition, read models, sagas and copies kept by events, and how far to isolate them, from private tables to a server per service.Shared Database — Several services reading and writing one database's tables: why the schema turns into an unwritten contract, why migrations, load and business rules couple the teams, the cases where one database is the right call, and the way out one table at a time.Wire Tap — A fixed step in a channel that copies every message to a second channel and passes the original on unchanged, so you can see what went down the channel without changing what is delivered.Resequencer — A stateful step that holds out-of-order messages by a sequence number assigned at the source and releases them in order: the next-expected counter, what the numbers must be, how long to wait for a missing one, what to do when the wait ends, and the message that arrives after its gap was skipped.Service Activator — A receiving endpoint that turns each message into a call to an existing service method, so the same service serves synchronous callers and messages alike, and turns the outcome back into a reply or into what happens to the message: acknowledged, redelivered or set aside.Correlation Identifier — A unique id the requester puts on each request and the replier copies onto the reply, so the requester can match every reply to the request still waiting for it, and recognise a reply that comes too late or twice.Message Endpoint — The code inside an application that connects it to one messaging channel, so the rest of the application deals in domain objects and calls, not in the messaging API: one endpoint per channel, sending or receiving, and on the receiving side a choice between polling for messages and being called with them.Detour — A router, switched from outside by a control message, that sends messages through extra steps such as validation or testing and then back onto the main path: who flips the switch, rejoining the path unchanged, and what the detour costs while it is on.Timeout — Bound how long a caller waits: what giving up does and does not undo, connect and read timeouts, choosing the number from measured latency and the caller's deadline, and passing the remaining time down a chain.Fallback — Decide what to answer when a call fails: a cached value, a default, a reduced feature, another source or a clear error, and avoid the fallbacks that hide an outage or knock over something else.Back-Pressure — How a slow consumer's "slow down" travels upstream hop by hop, through a blocking queue, the network's own flow control or explicit demand, and what to do at the edge where the source cannot be slowed.Rate Limiter — Where a rate limiter sits and whose limit it enforces: at the public edge, in front of an internal dependency, or on your own side of a third party's quota, and how many workers share one quota.Idempotency Key — A key the client generates once per intended operation and sends with every retry, so the server can recognise a repeated request and return the stored response instead of acting twice: what the server records, what it does with a duplicate still in flight or a reused key with a different payload, and how long keys are kept.Blue-Green Deployment — Run the next release in a second, complete production environment, test it there while nobody uses it, then move all traffic with one switch and switch back to roll back: where the switch lives, what happens to requests and sessions already on the old side, the database both sides share, and how long the way back stays open.Canary Deployment — Send a small share of traffic to a new version, compare it with a baseline of the old one, ramp it up in steps while the comparison holds and abort automatically when it fails: where the split happens, keeping each user on one version, which metrics to compare, and how long each step has to last.Parallel Run — Send the same real requests to the old and the new implementation, use only the old one's answer, and compare the two until every difference is understood: keeping the new path's side effects out of the world, triaging the diffs and recording known differences, shadow traffic and dark launches, and deciding when to cut over.Feature Toggle — Switch behaviour on or off at runtime without redeploying, with the decision made in one place in the code and each release toggle removed once its rollout is done.Distributed systems primitives — A map of the primitives behind distributed data systems: the question each one answers, the article that teaches it, and how two classic designs of a replicated store compose them differently.Write-Ahead Log — Why a database can answer COMMIT before its data files change: append the change to a sequential log, flush it, and let the pages follow later. What a flush really reaches, group commit, redo from a checkpoint, log sequence numbers, and what keeps the log from shrinking.Gossip Protocol — How a cluster with no master keeps one membership list in step: a round of push-pull with random peers, why news reaches a thousand nodes in about ten rounds with a flat number of exchanges per node, how heartbeat counters turn silence into a verdict, why the timeout is a trade-off, how SWIM's indirect probes cut false verdicts, and what gossip never promises.Concurrency patterns — Concurrent work either shares memory behind locks, hands data over to a single owner, or runs on one thread that never waits. Where each choice moves the difficulty, and which pattern answers which problem.Mutex and semaphore — How a read-modify-write loses updates between threads, how a mutex makes a critical section exclusive and a semaphore caps it at N, and how two locks taken in opposite orders deadlock.Producer-Consumer — Put a bounded buffer between code that makes work and code that does it, so each side runs at its own pace: producers wait when the buffer is full, consumers wait when it is empty.Thread Pool — Why one thread per task collapses under a burst, how a fixed set of workers pulling from a queue bounds the work, how many workers to run, and how a pool deadlocks when its tasks wait on each other.Event Loop — One thread serves thousands of connections by never waiting on any of them. Handlers run one at a time, to completion, which removes most locks and makes every slow handler everyone's problem.Future / Promise — Why a slow call hands back a placeholder instead of its result: pending, fulfilled and rejected, chaining instead of nested callbacks, what async/await and Promise.all do, and three ways a result goes missing.Reactor — How one thread waits on thousands of sockets and runs the right code for each: the demultiplexer, the handler registry and the register-wait-dispatch cycle, readiness versus completion, level- versus edge-triggered, why write interest is temporary, and why epoll outlasts select.Actor Model — Give each piece of state one owner that only messages can reach and that handles them one at a time. What that removes, what an asynchronous send does and does not promise, how supervisors restart failed actors, and where actor systems still jam.UI architecture: keeping screens apart from domain rules — Why screen code that mixes domain rules, presentation decisions and drawing is slow to test and risky to change, the Model and View split that MVC, MVP and MVVM share, the one question that tells them apart, and the leaks that undo the split.MVC: Model, View, Controller — In the original MVC a Controller turns the user's input into calls on the Model, and every View watching that Model redraws when it changes, which is not what web frameworks mean when they use the same name.MVP: Model, View, Presenter — MVP moves a screen's decisions out of the View into a Presenter that drives the View through a small interface, so a test can check them against a fake View. The price is pushing every change by hand, and keeping the Presenter from calling a View that is already gone.MVVM: Model, View, ViewModel — In MVVM a ViewModel holds a screen's state in the form the screen shows it, and the View binds to it instead of being told what to show. Because the ViewModel never references the View, a test can drive it with no screen at all, though the binding brings its own surprises.Unidirectional data flow: actions, store & view — Why UI state should change in one place: views emit actions describing what happened, a store computes the new state, and views redraw from it; reducers, selectors, replayable bugs, where side effects go, and what stays out of the store.Application Service (DDD) — The entry point for one use case: it loads the aggregate through its repository, calls the domain, saves, commits and publishes, and keeps business rules, HTTP and SQL out. Why every caller of the use case goes through it, why it is the transaction boundary, and the signs that it is getting fat.Policy (reactive rule) — A named business rule that reacts to an event: whenever this happens, issue that command. One trigger, one rule, no memory across steps, written so a domain expert can read and correct it.Message Broker — A separate process that accepts, stores and routes messages between applications, so each one knows only the broker and never another application's address: what that takes off the senders, and what it costs to run the one piece every flow now passes through.Messaging Gateway — Give application code a typed method in place of the messaging API, and make its contract say what the call promises: when it returns, which errors and timeouts it raises, and whether a retry can send the message twice.Channel Adapter — Some systems will never publish an event and may not be changed, so a component outside them reads what they already expose and turns it into messages, or turns messages into calls on them, and inherits every blind spot of the way it reads.Content Enricher — When a message reaches a consumer without the data it needs, one step fetches that data from a reference source and sends a fuller message on, and has to decide what happens when the lookup fails and which version of the data it adds.Content Filter — Each message on its way to one consumer loses the fields that consumer does not need or must not see. The rule is safest when it names the fields to keep, and the filter protects nothing that handled the message before it.Recipient List — A router that works out, for each message, which set of receivers needs it and sends each one a copy, so the audience can change from one message to the next without the sender knowing any of them.Return Address — The request message carries the name of the channel its reply must be sent to, so the replier answers whoever asked without knowing any caller, and each caller, or each instance of one, can get its replies on a channel of its own.Invalid Message Channel — A separate channel where a consumer puts every message it cannot accept as valid (unparseable, wrong version, unknown type, missing field), kept with its raw bytes, the reason and its source, so the producer's owner can fix it while the main flow keeps moving.Enterprise Integration Pattern catalog roles — A guide to the Enterprise Integration nodes, one plain line per role, and how to tell when a named node earns its place on a Grid.AI Agent Orchestration patterns — How several AI agents divide one job: sequential, concurrent, maker-checker, handoff, group chat and planner-led shapes, what passes between the agents, what ends the run, and what each extra hop costs.Queue-Based Load Leveling — Put a queue between bursty producers and a steady consumer, so a spike becomes a backlog drained over time instead of an overload: latency traded for stability.Backends for Frontends (BFF) — Why one general-purpose API serves clients with different screens, payload budgets and release cycles badly, and how one backend per client experience, owned by that client's team, shapes the data while business rules stay in shared services.Microkernel / Plugin — A minimal core runs the workflow that never varies and discovers optional plug-ins through fixed extension points: the registry that finds them, the contract they all depend on and how to version it, what belongs in the core, and how far a faulty plug-in can reach.Service Registry — How a registry's list of a service's live instances stays close to true as they register, renew, expire and leave, and what callers do while it is wrong or down.Modular Monolith — One application, built and deployed as a unit, divided into business modules that each publish an interface and own their data, even inside one database. How those boundaries are checked, and why they make a module easier to extract later.Load Shedding — When a server is past its capacity, refuse the excess early and cheaply: the signal that says it is full, which requests to drop first, what the refusal should say, and why queueing the surplus usually serves nobody.Failover — Move traffic from a failed primary to a standby without ending up with two primaries: fence the old one before promoting the new, and add up how long detection, promotion and redirect leave clients waiting.Request Hedging — After a latency threshold, send a duplicate request to a second replica and take whichever answer arrives first: why a high threshold keeps the extra load small, and why that stops being true when every replica is slow.Flowchart basics: start, process, end — What a flowchart says that a paragraph can leave out, the four shapes of a straight run of steps, and why a path that finishes needs an explicit End.Decisions & branching — How a Decision node splits a flow on a yes-or-no question, and how to chain Decisions so every value lands in exactly one outcome.Merge & path convergence — Why a normal step refuses a second incoming edge, and how a Merge brings several paths into one shared step.Loops & retries — Build a loop by feeding a decision's branch back through a Merge, then give it an exit and a pause between attempts.Split & parallelism — Fan one path out to parallel branches with no order between them, see what that saves, then bring the branches back together.State machines as flows — Draw a lifecycle so that each box names where the entity is and each edge is a legal move, give every state that can fail or be cancelled its own way out, and know what the drawing cannot enforce.Subprocesses & reusable steps — Collapse a detailed section of a flow into one Subprocess step, call a routine shared by several flows with a Predefined Process, and stop nesting before the top level stops telling the story.Error handling & error boundaries — Route each failure through a Decision on the step's outcome to an Error Boundary that logs, compensates, alerts or gives up, and ends at its own End instead of the happy path's.Data, documents & manual input — Show where data crosses a flow's boundary and who produces it: Input/Output, Manual Input, documents read or produced, and the setup step that primes what follows.Connectors, off-page links & delays — Replace an edge that crosses the whole page with a labelled jump, move a long flow onto a second diagram, and draw a deliberate wait so nobody takes it for a missing step.Stored data, displays & manual steps — Show where a flow persists data, shows something to a person, or has to wait for work only a person can do.Swimlanes & responsibility — Group flow steps into lanes so the diagram shows who owns each step, and every handoff between owners shows up as a line crossing lanes.Junctions: Or & Summing — Two circles that look alike and promise opposite things: an Or continues when any incoming path arrives, a Summing Junction once all of them have.Gateways: parallel, inclusive & event — BPMN-style gateways that open all, some or only the first of a flow's paths, and what the point where those paths meet again has to wait for.BPMN events: timer, message & boundary — What a BPMN event is, how a flow waits for a message or a deadline, how a boundary event interrupts a task or runs beside it, and how to draw each one with the Grid's flow stencils.Predefined process, data & loops — Call a routine defined elsewhere, mark the data one step hands to the next, and bound a repeat with a Loop Limit pair so the exit condition can be read on the drawing.Composing a resilient flow — What breaks where a parallel fork, a retry loop and a join meet: a join waiting for a branch that will never arrive, a retry that re-runs every branch, and a cap the other branch pays for.Storage & ordering stencils — What Multi-document, Internal Storage, Sort and Collate each promise the next step, and how they differ from Document, Stored Data and Merge.The class box: name, attributes, operations — The three compartments of a UML class, how visibility, types and operation signatures are written in them, and when a set of values becomes an Enumeration.Association, aggregation, composition — The lines between class boxes, the ownership question that picks one, and the multiplicity and arrowheads that make a line say something precise.Object diagrams: one moment of a running system — Instances instead of types: how an object diagram shows one concrete state with named objects, slots holding values and links between them, how that snapshot tests a class diagram's multiplicities and ownership, and why one snapshot can show a state is possible but never that every state is valid.Inheritance, interfaces and abstract types — How to draw and read generalization and realization in a class diagram, how abstract classes and interfaces are marked, and what each arrow claims about the code.SOLID design principles — Five principles for object-oriented code that stays cheap to change, each met at the moment one billing module starts to hurt without it.Packages, notes and dependency direction — Grouping types into packages so the arrows between them state a rule the code must follow, where a contract goes so every arrow points inward, what a note is for, and how a cycle between packages shows on the diagram.The C4 model: context, containers, components, code — Four levels of zoom for drawing a software system, what belongs at each one, and the labels that keep a diagram at its level.Entity-relationship modelling — Entities and their keys, weak entities, relationships, cardinality with its optional side, and the join entity of a many-to-many: the data half of low-level design.Normalisation & denormalisation — Why a fact stored twice can drift apart, how the first three normal forms give each fact one home, and when a deliberate copy is worth what it costs to keep correct.Sequence diagrams: who calls whom, in what order — Lifelines, calls and their replies, asynchronous messages, activation bars, combined fragments for the paths that branch, and the destruction that ends a participant, drawn for a login and traced step by step for a checkout that can be declined.State machines: states, events and guards — UML state modelling, and how it differs from the flowchart you might reach for instead.Use cases, actors and the system boundary — Deciding what the system is responsible for and what it merely talks to: actors outside, use cases named as goals inside, the boundary between them, and the include and extend arrows. The diagram to draw first when the scope is in doubt.