Tag
94 articles tagged #Production.
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.03WAL mode lets SQLite readers and a writer work at once. Here is how it works, the pragmas to set, and the three ways it bites in production.
P.04Go 1.27 shipped August 19 with generic methods, json/v2 under the hood and a GA goroutine leak profile. What to test before you bump go.mod.
P.05A 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.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.07Rotate a secret safely by provisioning the new value, running it alongside the old one, confirming every consumer, then revoking. Here's the runbook.
P.08vLLM v0.28.0 moved bitsandbytes quantization out-of-tree, breaking upgrades for 4-bit and 8-bit inference. How to check if you're affected and fix it fast.
P.09Offset pagination breaks under concurrent writes and gets slower on every page. Cursor pagination fixes both, at the cost of features you might actually need.
P.10Guardrails AI validates structured output, NeMo Guardrails controls dialog flow, and Llama Guard classifies safety. Here is which one fits your LLM app.
P.11Shared 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.12A public proof-of-concept for a Windows Defender privilege-escalation flaw has circulated since August 12 with no fix shipped. What to do about it now.
P.13Cloudflare 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.14Kubernetes 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.15Django 6.1 adds QuerySet.fetch_mode() to catch accidental N+1s, ON DELETE pushed into the database, and one MAILERS setting replacing loose EMAIL_ config.
P.16Random 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.17Two 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.18Polling 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.19Plain 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.20Argo Rollouts replaces a Deployment with a controller that shifts traffic gradually and rolls back on bad metrics. Real manifests, plain Deployment to canary.
P.21Three tools solve three different versions of "this query is slow." How materialized views, read replicas, and caches differ, and how to pick one.
P.22Every 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.23A 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.24Four AI code review tools, four tradeoffs. What differs between Copilot's built-in review, CodeRabbit, Greptile, and Qodo past the marketing, and seat costs.
P.25Deployment frequency, lead time, change failure rate, time to restore. What each measures, the tiers that separate elite teams, and where teams misuse them.
P.26Run 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.27A 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.28A 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.29An 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.30When production outruns consumption, a system must buffer, drop, or push back. How backpressure works across queues, streams, and APIs, with patterns.
P.31A 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.32Your Node process climbs until it's OOM-killed and restarting buys hours. The actual workflow: heap snapshot diffing, retainer paths, and the fast tools.
P.33An 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.34A 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.35Almost 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.36Pessimistic 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.37Soft 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.38Full 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.39PostgreSQL 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.40Chaos 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.41Event 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.42CAP 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.43GitHub cut token spend in its agentic CI workflows up to 62% by pruning unused MCP tools and swapping tool calls for CLI commands. How to copy the technique.
P.44Webhooks push the moment something happens; polling asks repeatedly. How to decide, with code for both, and the hybrid most production systems land on.
P.45A 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.46Round robin, least connections, and consistent hashing route traffic differently. Here's when each load balancing algorithm fits, with a hash ring example.
P.47Exponential 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.48Sharding splits one database across many machines. The strategy you pick decides whether you get hot spots, painful resharding, or something that scales.
P.49Writing 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.50Read 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.51When a transaction spans services you can't wrap it in one database transaction. Sagas use local transactions plus compensating actions. When that pays.
P.52Idempotency 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.53CQRS 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.54An N+1 bug turns one page load into hundreds of round trips. What causes it, how to spot it in Django, Rails, and Prisma, and the eager-loading fixes.
P.55PostgreSQL 19 Beta 1 adds REPACK, which rewrites bloated tables without a maintenance window, plus parallel autovacuum and smarter async I/O.
P.56A circuit breaker stops your app hammering a failing dependency until it recovers. The three states, a minimal implementation, and how retries differ.
P.57Firebase's complexity and Supabase's Postgres assumptions don't fit every project. How PocketBase, Appwrite, and Convex differ, and when each one fits.
P.58LLM bills grow faster than usage. Prompt caching, semantic dedup, tiered routing, and batch inference cut 40-80% without degrading output quality.
P.59Three 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.60OpenFeature is a CNCF incubating project with broad SDK support. How to use vendor-neutral feature flags, and why the standard beats the tool behind it.
P.61Logs say what happened. Error tracking says what broke, for which users, in what context. Setting up Sentry properly, without the alert fatigue.
P.62Rails 8 replaces Redis, Memcached, and Node with Solid Queue, Solid Cache, Solid Cable, and Kamal 2, so a single server and database can run production.
P.63Getting a language model to return reliably structured data is not just about asking nicely. Here's the pattern that actually works at production scale.
P.64MCP 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.65Most 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.66Blue-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.67CRDTs and sync engines make local-first apps feel instant and merge edits without conflicts. Here is how they work and whether your app actually needs them.
P.68Row Level Security moves tenant isolation into the database itself. How to set it up for a multi-tenant SaaS, handle the edge cases, and avoid the traps that break it.
P.69A hands-on comparison of Typesense, Meilisearch, and Algolia for production SaaS search: self-hosting, performance, pricing, and real implementation patterns.
P.70Building SaaS billing on Stripe means handling subscription plans, the Meter API for usage-based pricing, webhook reliability, and the Customer Portal.
P.71Zod is the standard for runtime type validation in TypeScript: one schema drives API contracts, form validation, and environment variables across your stack.
P.72RAG and fine-tuning solve different problems: one changes what a model knows, the other changes how it behaves. Here's how to decide which one you need.
P.73Password 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.74An 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.75Past the chatbot hype, AI is improving specific e-commerce outcomes. Here are the implementations producing measurable results, and the ones that still mostly disappoint.
P.76The queries that wreck production Postgres share a few root causes. How to find them, read EXPLAIN ANALYZE properly, and fix them without guessing.
P.77TypeScript leaves errors untyped by default. Effect TS fixes that with typed failures, dependency injection, and structured concurrency.
P.78RAG, constrained generation, output validation, and self-consistency reduce LLM hallucination in production. Here is what each layer costs and when to use it.
P.79LiteLLM and OpenRouter add failover, cost caps, and model fallback to your LLM calls. Here is how each works and when a routing layer is worth building.
P.80Neon 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.81Connection 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.82From .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.83A practical incident response process for small teams: severity tiers, on-call rotations, better alerting, and blameless postmortems, no SRE org required.
P.84Leaked credentials are the most preventable breach category. When you need a real secrets manager, which one to pick, and what to do if you're still on .env.
P.85LLM observability means tracking traces, token costs, latency, and output quality to debug production failures instead of guessing. Covers Langfuse and Helicone.
P.86OpenAPI-first API development means writing the spec before code, then generating server types, request validation, and client SDKs from it.
P.87Background jobs that crash mid-run lose their state. Temporal makes workflows durable state machines that survive restarts and deploys. In TS and Python.
P.88Unit tests confirm your code runs. They don't confirm your AI feature gives good answers. Here's how to build an eval pipeline that catches real failures.
P.89Feature flags let you ship AI features to a small slice of users first, watch for quality problems, and kill the feature in under a minute if something breaks.
P.90ALTER 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.91Async Django helps when a view waits on several slow network calls. It won't speed up CPU work or single queries, and the async ORM still runs sync underneath.
P.92EditorPickWhat breaks when you move from Celery to Django 6.0's Tasks framework, which workloads migrate cleanly, and when you should stay on Celery.
P.93EditorPickThe network latency between your Django app and your FastAPI ML service is probably longer than inference itself. Here is how to serve models from Django directly.
P.94EditorPickMost AI agents fail in production. Here are the architecture patterns, error handling strategies, and guardrails we use to build agents that actually ship.