Category
77 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 77 articles
P.01Run three copies of a service for availability and you've created a new problem: only one of them should do certain jobs at a time. Here's how leader election actually works, from Raft's term-based voting to the etcd lease pattern most teams use in practice.
P.02A log line that's just a sentence is fine until you have to search a million of them at 2am. Here's how structured logging actually works, how to thread a correlation ID through a request, and which fields are worth the storage cost.
P.03An index turns a table scan into a handful of comparisons, but only for the queries it was built for. Here's how B-tree indexes work under the hood, when clustered and non-clustered indexes diverge, and why adding one can slow down writes you weren't thinking about.
P.04When something produces work faster than something else can handle it, the system has to do one of three things: buffer, drop, or push back. Here's how backpressure actually works across queues, streams, and APIs, with real implementation patterns.
P.05A message that fails every time it's retried shouldn't loop forever or vanish silently. Here's how dead letter queues catch it, how to configure retry limits properly, and the reprocessing workflow that actually closes the loop.
P.06AMD acquired Taalas on August 6, a startup that hardwires model weights directly into chip silicon instead of loading them from memory. Here's what that trade-off means for inference cost, and why it can't replace your GPU fleet.
P.07A single checkout request might touch five services and nobody can say which one is slow. Distributed tracing fixes that by tagging every hop with one trace ID. Here's how spans, trace IDs, and context propagation actually work, with OpenTelemetry examples.
P.08An SLA is a promise with a penalty. An SLO is the internal target that keeps you inside that promise. An error budget is what's left before you breach it. Here's how the three fit together, with the math worked through on a real example.
P.09SambaNova raised $1 billion at an $11 billion valuation on July 8, 2026, to build inference-specific chips instead of training hardware. What the inference funding wave means for teams running AI in production.
P.10The short answer: BullMQ for Node, Celery for Python, Sidekiq for Ruby, and Temporal or a cloud-managed queue when you need durability without owning broker infrastructure. Here's the reasoning, a comparison table, and working code.
P.11Partitioning and sharding both split data up, and people mix up the terms constantly. Partitioning stays on one database and one server. Here's how range, list, and hash partitioning actually work, and when a partitioned table solves your problem before you need sharding at all.
P.12Read Committed, Repeatable Read, Serializable: most developers pick whatever their ORM defaults to and never ask why. Here's what each isolation level actually prevents, what it still allows, and how to pick one on purpose.
P.13Amazon Bedrock Agents, launched in 2023, is now 'Agents Classic' and closes to new customers on July 30, 2026. Its model catalog freezes too. Here's what that means and how to move to AgentCore.
P.14A 3-hour-33-minute CloudFront VPC Origins failure on July 16, 2026 knocked out at least ten unrelated services worldwide. The root cause was a single-ingress design decision, and it's a pattern worth checking your own architecture for.
P.15Kubernetes 1.36 shipped 70 enhancements with no headline rewrite, just years of accumulated work reaching stable. Here's what actually changes for platform teams, and what's safe to skip for now.
P.16A unit-pricing bug in AWS's billing estimate subsystem sent some customers cost projections in the billions and trillions on July 16. Invoices were unaffected, but automation wired to those estimates wasn't. What happened, and how to build cost alerting that fails safely.
P.17PostgreSQL 18 shipped in September 2025 and is now on its 18.4 point release. With PostgreSQL 19 still in beta, here's what 18's async I/O, UUIDv7, virtual generated columns, and OAuth support actually mean for a production upgrade decision today.
P.18Chaos engineering means deliberately injecting failure into a running system to find weaknesses before an outage does. Here's what it actually involves, what tools make it practical, and when a smaller team should and shouldn't bother.
P.19Most 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.20CAP 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.21In under three months, one developer rebuilt Postgres from scratch in Rust using AI coding agents, and pgrust now matches Postgres 18.3's output across more than 46,000 regression queries. Here's what it actually is, and isn't, and why it matters.
P.22A 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.23Round 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.24A 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.25Sharding splits one database across many machines when a single server can't hold or serve your data anymore. The strategy you pick determines whether you get hot spots, painful resharding, or a system that actually scales. Here's how each one works.
P.26Writing to your database and publishing an event are two separate operations, and a crash between them silently loses data. The transactional outbox pattern closes that gap. Here's how it works and how to implement it.
P.27Adding read replicas is the standard fix for a database under read load, but it introduces a gap between when data is written and when it's readable everywhere. Here's what replication lag actually does to your application and how to design around it.
P.28When a business transaction spans multiple services, you can't wrap it in one database transaction anymore. The saga pattern solves this with a chain of local transactions and compensating actions. Here's how it works and when it earns its complexity.
P.29PostgreSQL 19 Beta 1 shipped with a REPACK command that finally makes VACUUM FULL and CLUSTER safe to run without a maintenance window, plus parallel autovacuum and smarter async I/O. Here's what changed and what to test now.
P.30A circuit breaker stops your application from hammering a failing dependency until it recovers. Here's how the pattern works, the three states that make it up, and how to implement one without over-engineering a simple retry.
P.31Firebase's complexity and Supabase's Postgres assumptions do not fit every project. PocketBase, Appwrite, and Convex each solve the backend problem differently. Here is when each one makes sense.
P.32Three tools, three different bets on where complexity belongs. Here's how to choose between BullMQ, Inngest, and Temporal based on what your system actually needs — not what sounds most impressive.
P.33Durable Objects solve the coordination problem that makes edge computing hard: how do you maintain consistent state across distributed nodes? Here's how they work and when to use them.
P.34Kafka is the default answer for message queuing at scale. But for teams running fewer than a million messages per day, NATS JetStream offers persistence, delivery guarantees, and a dramatically simpler operational footprint.
P.35A practical guide to setting up metrics collection with Prometheus and visualization with Grafana for backend services — what to instrument, what to skip, and what the dashboards should actually show.
P.36Dev Containers let you define your entire development environment in a JSON file. New team members are productive in minutes, not days. Here's how to set them up properly.
P.37A bloated Docker image costs you in pull times, storage fees, and attack surface. Here's how to build images that are small, fast to rebuild, and genuinely production-ready.
P.38R2'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.39Logs tell you what happened. Error tracking tells you what broke, in what context, for which users. Here's how to set up Sentry properly and avoid the alert fatigue that makes it useless.
P.40The fear of vendor lock-in leads to over-engineering. Here's a practical framework for deciding when to abstract cloud dependencies and when accepting lock-in is the right call.
P.41ClickHouse is a columnar database designed for analytical workloads. It answers queries over billions of rows in seconds that would take minutes in Postgres. Here's what application developers need to know.
P.42dbt 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.43Vercel dominates frontend hosting. AWS dominates enterprise infrastructure. Between those two extremes, Fly.io and Railway are the most practical choices for backend-heavy full-stack apps in 2026.
P.44Workers AI gives you access to a catalog of open-weight models — Llama, Mistral, Whisper, embedding models — running in Cloudflare's network. Here's what's actually useful, what the limitations are, and when it makes sense.
P.45SQLite 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.46Blue-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.47eBPF lets you attach programs to any kernel hook — network packets, system calls, function calls — without patching the kernel or rebooting. Here's what application developers actually need to know.
P.48Tailscale creates a private mesh network across any combination of cloud servers, developer laptops, and office machines — without port forwarding, firewall rules, or dedicated VPN hardware.
P.49Multi-cloud gets pitched as the default choice for serious companies. The reality is more nuanced — and for most teams, the complexity cost is higher than the lock-in risk it's supposed to prevent.
P.50OpenTelemetry is the observability standard now. Most tutorials show you how to install the SDK and emit traces. Fewer explain which signals actually matter for web applications and which add noise without helping you debug anything.
P.51Password resets, invoices, and notification emails are infrastructure. Most developers treat them as an afterthought until a client asks why their welcome emails are disappearing. Here is the full picture.
P.52HPA 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.53The queries that destroy production Postgres databases share a small set of root causes. Here is how to find them, understand what EXPLAIN ANALYZE is telling you, and fix them without guessing.
P.54Neon separates storage from compute to make Postgres behave like a serverless resource. The branching feature is what actually changes the development workflow — here's how it works and when it's worth the migration.
P.55Connection exhaustion is one of the most common production failures for apps that scale. Here's how pooling works, which tool fits which setup, and the configuration decisions that matter.
P.56From .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.57Site reliability engineering was designed for teams of hundreds. Most of its principles translate directly to teams of 5. Here is what a practical incident response process looks like when nobody has 'SRE' in their title.
P.58Service meshes promise secure, observable microservice communication. But most teams that adopt one do so before they need it. Here is how to decide, and what each option actually costs you.
P.59Message 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.60Every 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.61Background jobs that crash mid-execution lose all their state. Temporal solves this by making workflows durable state machines that survive process restarts, deploys, and outages. Here's what it looks like in TypeScript and Python.
P.62Most teams treat their CI pipeline as a black box that occasionally fails. A few hours of optimization can cut your CI time by 40-60% and your GitHub Actions bill by a similar margin. Here's exactly how to do it.
P.63HashiCorp moved Terraform to a Business Source License in August 2023. OpenTofu forked it under the MPL. Pulumi took a different path entirely. Two and a half years on, the dust has settled enough to make a clear-headed choice.
P.64In March 2024, Redis Ltd. relicensed Redis under a source-available license. Within weeks, the Linux Foundation forked it as Valkey. Two years on, here's how the split played out and what it means for teams choosing an in-memory data store today.
P.65LLM calls are slow and expensive. Caching them is the obvious move. But caching the wrong responses breaks the user experience in ways that are subtle and hard to debug. Here's a practical guide to doing it right.
P.66ALTER 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.67Traditional monitoring tells you a request took 800ms. It doesn't tell you the LLM spent 600ms on a bad prompt, returned a hallucinated answer, and burned $0.04 in tokens. Here's how to actually instrument AI applications with OpenTelemetry.
P.68Explore the financial impact of the AI storage tax and the sharp rise in NAND and RAM costs, affecting enterprise IT budgets and cloud infrastructure strategies.
P.69Explore the shift towards serverless edge computing in the post-cloud era, focusing on performance improvements, cost savings, and real-world case studies of enterprises leveraging this technology.
P.70Analyzing the February 2026 Cloudflare edge network outage: cascading failures, bypassed canary deployments, R2 and Workers impact. Real architecture lessons for building resilient distributed systems.
P.71Data-driven analysis of platform engineering adoption in 2026. Compare Backstage, Port, and Cortex IDPs, golden paths, self-service infrastructure, and how to measure platform success with DORA metrics.
P.72Learn how to deploy WebAssembly applications on Kubernetes using SpinKube and containerd-wasm-shim. Step-by-step tutorial covering cluster setup, Spin app deployment, monitoring, and production readiness.
P.73EditorPickEveryone said WebAssembly would kill Docker. Two years later, they coexist — and the teams using both are shipping faster. A reality check on Wasm, containers, and the containerd shim approach.
P.74Everyone says go cloud-native. But what does that actually mean in 2026? We break down microservices, serverless, and containers — and why most teams should start simpler than they think.
P.75We benchmarked Supabase Edge Functions, Vercel Serverless, and Fly.io containers head-to-head. Here are the real cold start times, throughput, and costs.
P.76AWS and Google Cloud announced cross-cloud interconnect integration with encrypted-by-default networking. After years of vendor lock-in wars, competitors are collaborating. We break down what it means and what it does not.
P.77GitOps adoption hit 64% in 2025, and the next evolution is integrating real-time cost visibility into every infrastructure pull request. We break down why GitOps plus FinOps is the operational model serious teams are adopting in 2026.