Category
87 articles in Cloud & Infrastructure.
About this section
Infrastructure decisions are the ones you live with longest and revisit least, usually because revisiting them is expensive. So this section leans toward comparisons made under real constraints rather than benchmarks made under ideal ones: edge against serverless against containers for a specific workload, what a managed database costs once traffic is uneven, why a platform's scale-to-zero behaviour matters more than its cold start numbers. Postmortems get a lot of space, ours and other people's, because an outage report tells you more about a system than its documentation does. If you are choosing a platform for something that has to run unattended, the failure modes here are the ones worth reading before the pricing page.
All 87 articles
P.01PostgreSQL 14 gets its last release on November 12, 2026. Pick 18 (or 17), choose pg_upgrade or logical replication, and fix what breaks between 14 and 18.
P.02How gossip protocols spread state across a cluster in log(N) rounds, why Cassandra and Consul use them, and a 20-line simulation you can run yourself.
P.03A runbook people follow at 3 a.m. is short, starts with a check, and ends with a decision. Here is the template we use, with a worked example.
P.04PostgreSQL 19 beta adds ON CONFLICT DO SELECT, GROUP BY ALL, FOR PORTION OF and JSON output for COPY. Runnable examples and what each one replaces.
P.05When a popular cache key expires, every waiting request hits your database at once. Here's why that happens and four real ways to stop it.
P.06Cron jobs fail in three specific ways in production: overlapping runs, missed runs after downtime, and silent failures nobody notices. Here's how to close all three.
P.07Postgres won't convert a live table into a partitioned one in place. Here's the CHECK-constraint trick that avoids a full-table rewrite and a long lock.
P.08A cold start is the fresh execution environment a platform builds before running your code. Some take 5ms, others 2 seconds. Here's why, and how to cut it.
P.09TEEs 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.10Cloudflare 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.11Kubernetes 1.37 shipped August 26 with 67 enhancements. What actually graduated to stable, what's worth testing in beta, and what to leave alone for now.
P.12Two 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.13Polling 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.14Argo Rollouts replaces a Deployment with a controller that shifts traffic gradually and rolls back on bad metrics. Real manifests, plain Deployment to canary.
P.15Three tools solve three different versions of "this query is slow." How materialized views, read replicas, and caches differ, and how to pick one.
P.16Every rolling deploy drops a few requests and the errors look like client noise. The shutdown sequence, the race behind it, and the code that fixes it.
P.17A 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.18Run 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.19A log line that's just a sentence is fine until you search a million at 2am. How structured logging works, threading a correlation ID, and what to skip.
P.20An index turns a table scan into a few comparisons, but only for the queries it was built for. How B-trees work, and the write cost nobody budgets for.
P.21When production outruns consumption, a system must buffer, drop, or push back. How backpressure works across queues, streams, and APIs, with patterns.
P.22A 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.23One checkout request touches five services and nobody knows which is slow. How trace IDs, spans, and context propagation fix that, with OpenTelemetry code.
P.24An 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.25BullMQ for Node, Celery for Python, Sidekiq for Ruby, and Temporal or a cloud queue when you need durability without owning a broker. The reasoning.
P.26Partitioning and sharding get confused constantly. Partitioning stays on one server. How range, list, and hash work, and when it solves it before sharding.
P.27Most developers use whatever their ORM defaults to. What Read Committed, Repeatable Read, and Serializable prevent, what they allow, and how to choose.
P.28Bedrock Agents Classic closes to new customers on July 30, 2026, and its model catalog freezes too. What that means, and how to move over to AgentCore.
P.29Kubernetes 1.36 shipped 70 enhancements with no headline rewrite, just years of work reaching stable. What changes for platform teams, and what to skip.
P.30A unit-pricing bug sent some AWS customers cost projections in the billions on July 16. Invoices were fine; automation wired to those estimates wasn't.
P.31PostgreSQL 18 is on 18.4 and 19 is still beta, so 18 is what you should run today. What async I/O, UUIDv7, and virtual generated columns actually buy you.
P.32Chaos 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.33Most teams default to cache-aside without asking if it's right. How cache-aside, write-through, and write-behind behave under real traffic, and how to pick.
P.34CAP theorem forces a consistency-versus-availability choice during a network partition, not all the time. Here is what it constrains and how to pick a model.
P.35One developer rebuilt Postgres in Rust with AI agents in under three months, and pgrust now matches 18.3 across 46,000+ regression queries. What it isn't.
P.36A distributed lock stops two processes on separate machines from touching the same resource at once. Here's how Redis, ZooKeeper, and fencing tokens work.
P.37Round robin, least connections, and consistent hashing route traffic differently. Here's when each load balancing algorithm fits, with a hash ring example.
P.38Exponential backoff plus jitter stops retries from turning a blip into an outage. Working code, what not to retry, and how to bound the loop.
P.39Sharding splits one database across many machines. The strategy you pick decides whether you get hot spots, painful resharding, or something that scales.
P.40Writing 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.41Read replicas are the standard fix for read load, but they open a gap between writing data and reading it back. What lag breaks, and how to design around it.
P.42When a transaction spans services you can't wrap it in one database transaction. Sagas use local transactions plus compensating actions. When that pays.
P.43PostgreSQL 19 Beta 1 adds REPACK, which rewrites bloated tables without a maintenance window, plus parallel autovacuum and smarter async I/O.
P.44A circuit breaker stops your app hammering a failing dependency until it recovers. The three states, a minimal implementation, and how retries differ.
P.45Firebase's complexity and Supabase's Postgres assumptions don't fit every project. How PocketBase, Appwrite, and Convex differ, and when each one fits.
P.46Three 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.47Durable Objects solve edge computing's coordination problem: consistent state across distributed nodes. Here's how they work and when to use them.
P.48Kafka is the default for message queuing at scale. For teams under a million messages a day, NATS JetStream gives the same guarantees with far less overhead.
P.49Setting up metrics with Prometheus and dashboards with Grafana: what to instrument, what to skip, and what a dashboard should show during an incident.
P.50Dev Containers define your entire dev environment in a devcontainer.json file, so new teammates are productive in minutes. Here's how to set them up.
P.51Multi-stage Docker builds cut image size by 80-90%, speeding up pulls, cold starts, and CI, while shrinking your attack surface and registry bill.
P.52R2's zero-egress pricing looks compelling on paper. Here's when it actually saves money, when S3's ecosystem still wins, and how to migrate if you decide to switch.
P.53Logs say what happened. Error tracking says what broke, for which users, in what context. Setting up Sentry properly, without the alert fatigue.
P.54Every 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.55ClickHouse answers queries over billions of rows in seconds that take Postgres minutes. Here's how it works and what to know before adopting it.
P.56dbt turns SQL SELECT statements into a tested, documented, version-controlled data pipeline. Here's how it works and when you should add it to your data stack.
P.57Fly.io and Railway sit between Vercel's simplicity and AWS's complexity, making them the most practical hosts for backend-heavy full-stack apps in 2026.
P.58Workers AI runs open-weight models (Llama, Mistral, Whisper, embeddings) inside Cloudflare's network. What's useful, what the limits are, and when it fits.
P.59SQLite runs in every phone and browser. Turso extends it to the server and edge with replication, branching, and a network protocol. Here's when it makes sense.
P.60Blue-green and canary deployments limit the blast radius of a bad release. Here's how each works, with real Kubernetes and Argo Rollouts configs.
P.61eBPF attaches programs to any Linux kernel hook, network packets, syscalls, function calls, without patching the kernel. Here's what developers need to know.
P.62Tailscale is a mesh VPN giving distributed teams private networking between laptops, servers, and office machines in about 30 seconds, no VPN hardware needed.
P.63Multi-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.64OpenTelemetry is the observability standard now, but most tutorials skip the hard part: which signals help you debug, and which just add noise and cost.
P.65Password resets and invoices are infrastructure. Here's how SPF, DKIM, DMARC, IP warmup, and bounce handling decide whether your email lands in the inbox or spam.
P.66HPA scales on CPU and memory. But most production workloads don't scale well on those signals. KEDA, VPA, and Goldilocks fill the gaps that HPA leaves open.
P.67The queries that wreck production Postgres share a few root causes. How to find them, read EXPLAIN ANALYZE properly, and fix them without guessing.
P.68Neon separates storage from compute so Postgres can branch like git. Here's how the branching model works and when it's worth migrating for.
P.69Connection exhaustion is a common production failure at scale. Here's how pooling actually works, which tool fits which setup, and the config decisions that matter.
P.70From .env files to Vault to AWS Secrets Manager: a practical guide to storing credentials, API keys, and certificates without waking up to a breach notification.
P.71A practical incident response process for small teams: severity tiers, on-call rotations, better alerting, and blameless postmortems, no SRE org required.
P.72Most teams adopt a service mesh before they actually need one. Here's the decision framework, real cost tradeoffs, and when Istio, Linkerd, or Cilium earns its keep.
P.73Kafka isn't always the right call for event-driven systems. Choose between Kafka, Redis Streams, and BullMQ based on real throughput and durability needs.
P.74The multi-tenancy model you pick early is hard to change later. Compare database-per-tenant, schema-per-tenant, and row-level security by cost and isolation.
P.75Background jobs that crash mid-run lose their state. Temporal makes workflows durable state machines that survive restarts and deploys. In TS and Python.
P.76A few hours of optimization can cut CI time 40-60% and your GitHub Actions bill by a similar margin. Here's exactly how, with the configs that do it.
P.77HashiCorp's 2023 BSL relicensing split Terraform into OpenTofu, while Pulumi took a code-first approach. Here's how to choose between them in 2026.
P.78Valkey is the BSD-licensed Redis fork backed by AWS, Google, and the Linux Foundation. Here's how it diverged from Redis and when to migrate.
P.79LLM calls are slow and expensive, so caching is the obvious fix. Here's when it backfires and how to implement exact-match and semantic caching.
P.80ALTER TABLE locks your database. Your migration takes longer than expected. Users get errors. Here's how to handle schema changes that don't interrupt production traffic.
P.81Traditional monitoring won't tell you an LLM call burned $0.04 in tokens on a hallucinated answer. Here's how to instrument AI apps with OpenTelemetry.
P.82Backstage is open source and highly customizable but needs a team to run it. Port and Cortex are SaaS portals that start faster. How to choose and measure one.
P.83Deploy WebAssembly workloads on Kubernetes using SpinKube: cluster setup, Spin deployment, autoscaling, monitoring, and a production readiness checklist.
P.84EditorPickEveryone said Wasm would kill Docker. Two years later they coexist, and teams running both ship faster: a reality check on Wasm, containers, and the containerd shim.
P.85Cloud-native in 2026 means using managed infrastructure well, not microservices for everything. Here is how to pick between monoliths, containers, serverless.
P.86Multicloud is worth it for data residency rules, acquisitions, or a workload one cloud does far better. For most teams, one cloud across regions costs less.
P.87GitOps adoption hit 64% in 2025, but costs rose with it. Real-time cost visibility in every infrastructure PR is how serious teams are fixing that in 2026.