Tag
80 articles tagged #Architecture.
P.01A staff engineer is scoped by impact across teams, not seniority. Here is how to screen for that instead of promoting your best senior engineer.
P.02Shared database or one per customer? Most SaaS teams pick wrong for their stage and pay later. How the three patterns trade off, and which one you need.
P.03TEEs encrypt data even from the cloud provider running it, which is why confidential computing became a real AI requirement. What it does and doesn't cover.
P.04Spec-driven development treats a written spec, not code, as the artifact an AI agent builds from. How Spec Kit, Kiro, and BMAD differ, and when it's worth it.
P.05Cloudflare logged 13 incidents between August 7 and 14, touching R2, Durable Objects, and Workers KV. What that means for building on one edge provider.
P.06Random UUIDs wreck index locality; auto-increment leaks counts and won't shard. What UUIDv7, ULID, and Snowflake each give you, and the real tradeoffs.
P.07Two writes hit different replicas at once. Which came first? Sometimes neither. How vector clocks tell a real conflict from a false one, without wall time.
P.08Polling misses deletes, adds load, and always lags. CDC reads the write-ahead log instead, turning every insert, update, and delete into an event stream.
P.09Plain mod-N hashing reshuffles almost every key when you add a server. Consistent hashing moves roughly 1/N instead. Working code and a real simulation.
P.10Three tools solve three different versions of "this query is slow." How materialized views, read replicas, and caches differ, and how to pick one.
P.11A Merkle tree proves a piece of data belongs to a large dataset, or finds exactly what changed between copies, without reading all of it. How, and where.
P.12A Bloom filter answers one question in almost no memory: is this definitely absent, or possibly present. How it works, and why false positives are a feature.
P.13Run three copies of a service and only one should do certain jobs. How leader election works, from Raft's term voting to the etcd lease pattern teams use.
P.14A webhook receiver has to trust a request it can't control the timing, order, or count of. Verifying signatures, handling retries, surviving delivery chaos.
P.15When production outruns consumption, a system must buffer, drop, or push back. How backpressure works across queues, streams, and APIs, with patterns.
P.16Integration tests that boot every dependency are slow and flaky. Contract testing checks that consumer and provider agree on a shape without either running.
P.17A message that fails every retry shouldn't loop forever or vanish. How dead letter queues catch it, how to set retry limits, and the reprocessing workflow.
P.18VectorWare maps Rust's std::simd types onto GPU warps, so the same vector code runs on CPU and GPU. What it does, why it's hard, and where it still breaks.
P.19The algorithm choosing your elevator is the same family your kernel uses to schedule disk reads. How SCAN, LOOK, and destination dispatch actually work.
P.20One checkout request touches five services and nobody knows which is slow. How trace IDs, spans, and context propagation fix that, with OpenTelemetry code.
P.21An SLA is a promise with a penalty. An SLO is the internal target that keeps you inside it. An error budget is what's left. The math, on a real example.
P.22A circuit breaker stops calls to a failed service. A bulkhead stops a merely slow one from eating every thread and starving the rest of your app.
P.23Four philosophies for one problem: moving a schema from what it is to what it should be, safely, in a team. How they differ and which fits your stack.
P.24DDD has a reputation for ceremony that scares teams off before they see the idea. The idea is simple and solves a real problem. What it is, and when to use it.
P.25Almost every queue advertising exactly-once actually gives you at-least-once plus a way to make your handler idempotent. The real distinction, and why.
P.26Pessimistic locking stops one request from starting; optimistic lets both run and catches the conflict at the end. How each works, with SQL, and how to pick.
P.27Soft delete sounds like the safe default, but it quietly breaks unique constraints, foreign keys, and query performance unless you design for it up front.
P.28Full rewrites fail because the business can't stand still for two years, not because the new code is bad. How the strangler fig moves traffic piece by piece.
P.29Partitioning and sharding get confused constantly. Partitioning stays on one server. How range, list, and hash work, and when it solves it before sharding.
P.30Most developers use whatever their ORM defaults to. What Read Committed, Repeatable Read, and Serializable prevent, what they allow, and how to choose.
P.31A background task that outlives the function that spawned it is a real production bug. How structured concurrency fixes it in Python, Kotlin, and Swift.
P.32A practical comparison of the four vector databases teams actually shortlist for RAG, with real pricing, when each wins, and the question that decides it.
P.33A 3-hour-33-minute CloudFront VPC Origins failure knocked out ten unrelated services worldwide. The cause was a single-ingress design worth checking for.
P.34Chaos engineering injects failure into a running system to find weaknesses before an outage does. What it involves, what tools help, and when to skip it.
P.35Event sourcing stores every change as an immutable event and replays them for current state. What that buys, and the operational cost most systems skip.
P.36Hexagonal architecture stops business logic importing your database driver or payment SDK. How it works, a working example, and when you don't need it.
P.37Most teams reach for cache-aside by default and never ask if it's actually the right pattern. Here's how the three main caching strategies behave under real traffic, the consistency gap each one leaves open, and how to pick between them.
P.38CAP theorem gets summarized as 'pick two of three' so often that the summary has replaced the theorem. Here's what it actually says, why the real constraint only bites during a network partition, and how to pick a consistency model for a system you're actually building.
P.39Webhooks push the moment something happens; polling asks repeatedly. How to decide, with code for both, and the hybrid most production systems land on.
P.40A distributed lock keeps two processes on different machines from touching the same resource at once, but the naive Redis implementation has a gap that lets it fail silently. Here's how the pattern actually works, and the fencing token that closes the gap.
P.41Round robin isn't wrong, but it's the wrong default more often than teams realize. Here's how the main load balancing algorithms actually behave under uneven traffic, when each one earns its complexity, and a working consistent hashing implementation.
P.42A naive retry loop can turn a brief blip into a full outage by hammering a recovering service the instant it comes back. Here's how exponential backoff and jitter actually prevent that, with working code, not just the formula.
P.43Sharding splits one database across many machines. The strategy you pick decides whether you get hot spots, painful resharding, or something that scales.
P.44All three move messages between services, but answer different questions about delivery, replay, and who reads what. The decision, and the failure modes.
P.45Writing to your database and publishing an event are two operations, and a crash between them loses data silently. How the transactional outbox closes it.
P.46A single GraphQL schema works until several teams own different parts of the data. What federation solves, how Apollo composes subgraphs, and the cost.
P.47When a transaction spans services you can't wrap it in one database transaction. Sagas use local transactions plus compensating actions. When that pays.
P.48Teams are picking Rails, Elixir, and calmer backends over the framework of the month. Why boring is winning arguments it used to lose, and when it's wrong.
P.49Idempotency keys let a client retry a request that may have already succeeded, without double-charging a card. The pattern, in Postgres and in Redis.
P.50CQRS separates the path that changes data from the path that reads it. It solves real problems and is heavily over-applied. When it earns its complexity.
P.51A circuit breaker stops your app hammering a failing dependency until it recovers. The three states, a minimal implementation, and how retries differ.
P.52TC39 is standardizing signals, the reactive pattern already inside Vue, Solid, Angular, and Preact. Years from browsers, but it changes what to build on.
P.53How to assess a codebase before you buy, inherit, or partner on it: the documents to request, what kills deals, and what turns out to be fixable.
P.54Three tools, three bets on where complexity belongs. How to choose between BullMQ, Inngest, and Temporal based on what your system needs, not what sounds big.
P.55Every cloud decision locks you in somewhere; the real question is which lock-in costs less. A practical framework for when to abstract and when to accept it.
P.56An ADR captures why a technical choice was made, not just what. One page per decision, stored in the repo. Here's the format and how to make it stick.
P.57MCP is the standard for connecting AI models to external systems. How it works, how to implement a server, and what to lock down before production.
P.58Most slow queries come from a small set of fixable problems: missing indexes, N+1 patterns, and over-fetching. This is the practical diagnostic and fix guide.
P.59Blue-green and canary deployments give you a way to release software without taking down your service or discovering a bug when it's already affecting everyone. Here's how they work and when to use each.
P.60NestJS is Express with structure imposed: modules, dependency injection, decorators. When that pays for its learning curve, and when it does not.
P.61Local-first means your app works offline and syncs when connected. The technology (CRDTs and sync engines) is mature enough to use. The question is whether your use case actually needs it.
P.62Sanity, Contentful, Strapi and Payload compared on the criteria that decide it: who edits the content, where it's hosted, and whether schema lives in git.
P.63Row Level Security moves data isolation into the database where it belongs. Here's how to set it up for a multi-tenant SaaS, handle common edge cases, and avoid the traps that break it.
P.64Multi-cloud usually costs more in engineering time than the lock-in risk it prevents; most teams do better on one cloud with deliberate exceptions.
P.65Three leading agent orchestration frameworks, three different mental models. Here's when each one earns its place, what each costs you in complexity, and what the choice looks like when you're debugging at 2am.
P.66An agent that forgets everything when the session ends is a limited tool. Here are the practical patterns for building different kinds of memory into your agents.
P.67TypeScript leaves errors untyped by default. Effect TS fixes that with typed failures, dependency injection, and structured concurrency.
P.68gRPC has been available for years but many teams default to REST without thinking through the tradeoffs. Here's how gRPC works, where it fits, and where it doesn't.
P.69URL versioning, header versioning, and content negotiation compared with real code. Here's how to pick one and retire old versions without stranding clients.
P.70Message queues and event streams solve different problems. Kafka is not always the right answer. Here's how to think through event-driven patterns and choose the right tool for your production workload.
P.71Every SaaS team eventually faces the multi-tenancy decision. The wrong choice creates migration pain later. Here's how to think through database-per-tenant, schema-per-tenant, and row-level security based on what your product actually needs.
P.72Every public API needs rate limiting, but the algorithm you choose shapes the user experience and the failure modes. Here's how each approach works and when to use it.
P.73EditorPickHow we built production multi-agent systems with the Claude Agent SDK and MCP, covering orchestrator-worker patterns, handoffs, error handling, and tracing.
P.74EditorPickWe migrated three production projects from Celery to Django's new Tasks framework. Two went smoothly. One was a disaster. Here is everything we learned.
P.75EditorPickA deep dive into how we built codercops.com with Astro 5 SSR, Supabase as a CMS, Git-based content, and Edge Functions. Architecture decisions and lessons learned.
P.76How we built a Git-to-Supabase content pipeline with SHA-256 delta sync, Edge Functions, and GitHub Actions. Full architecture and code walkthrough.
P.77Every engineering team faces build vs buy decisions constantly. Here's a practical framework for making these decisions without analysis paralysis.
P.78Choosing a tech stack is one of the earliest and most consequential decisions for a startup. Here's a practical guide to making choices you won't regret.
P.79How we split our agency website into two repos — one for code, one for content — and why this architecture scales better than a monolith. With our exact Git submodule setup, GitHub Actions validation, and content workflow.
P.80EditorPickLearn the 5 SOLID principles of clean code through real-world analogies, humor, and simple examples. No PhD required - just common sense and a sense of humor.