Technical writing on building for the web: tutorials, insights and lessons learned from real projects.
// posts.sort((a, b) => b.publishedAt - a.publishedAt)
What we learned running our own SMTP server: SPF, DKIM and DMARC, reverse DNS, IP warm-up and keeping a sender reputation healthy.
One repository for web, admin and API: pnpm workspaces for strict dependencies and Turborepo caching so only what changed gets built.
Find debt hotspots with git history and incident data, explain the cost in business terms, and pay it down continuously instead of heroically.
Commands vs events, designing event contracts, at-least-once delivery, ordering and dead-letter queues in event-driven systems.
The handful of Kubernetes settings that prevent most production incidents: resources, readiness vs liveness, graceful shutdown and rollbacks.
Going from AI demo to production: fallbacks, grounding, prompt injection defenses, cost control and evaluation for LLM-powered features.
Most API versions are avoidable. How to evolve APIs without breaking clients, and how to version and deprecate when you really must.
Remote state, blast-radius splits, reviewing plans instead of code, deletion protection and drift detection — Terraform habits from production.
Coverage is not confidence. Why integration tests against real dependencies deserve the most investment, and how to keep tests trustworthy.
Timeouts, retries with jitter, circuit breakers, fallbacks and bulkheads: how to keep one failing dependency from taking down everything.
A structure for design docs that busy reviewers actually read: problem, goals, non-goals, alternatives, risks and a rollback plan.
Token buckets, sliding windows and an atomic Redis implementation for rate limiting across many API instances, with sensible failure modes.
A transaction alone does not make concurrent code safe. Lost updates, write skew and how atomic updates, locks and retries prevent them.
Most of your global store is really a cache of server data. Separating server state from client state makes React apps dramatically simpler.
Microservices solve organizational problems at a real operational cost. Start with a modular monolith and split only when the signals are clear.
Structured logs, RED metrics, OpenTelemetry traces and SLOs with error budgets — and why you should alert on symptoms, not causes.
Separate deploy from release with feature flags, roll out progressively, and avoid the flag debt that turns a superpower into a trap.
Composite column order, covering, partial and expression indexes, GIN for arrays and JSONB — and how to find the indexes nothing uses.
Reliable background processing with BullMQ: idempotent handlers, exponential backoff, unrecoverable errors, dead letters and graceful shutdown.
JWTs or sessions is the wrong question. Short-lived access tokens, rotating refresh tokens and reuse detection give you the best of both.
Fix LCP, INP and CLS for real users, then keep them fixed with a performance budget that fails the build when a regression slips in.
Database per tenant, schema per tenant or a shared schema? The trade-offs, and how we made tenant isolation automatic in a white-label SaaS.
Most postmortems end with "be more careful". Here is how to write ones that find real contributing factors and stop incidents from repeating.
Fast is easy, fast and correct is hard. Cache-aside, stampede protection and versioned keys for caches that never show stale data by surprise.
A practical, OWASP-driven security checklist for Node.js APIs: access control, injection, validation, dependencies, SSRF and secrets.
Saving to the database and publishing an event are two writes that can fail independently. The outbox pattern makes them one.
Hard-earned lessons from shipping the Next.js App Router: where to draw client boundaries, avoiding waterfalls and keeping secrets on the server.
Rename columns and change schemas on live tables without an outage, using the expand and contract pattern and lock-aware DDL.
Stop reviewing semicolons. A practical checklist for reviewing design, correctness, security and operability — and giving feedback people learn from.
Retries are inevitable. Learn how idempotency keys, atomic inserts and downstream keys keep a retried request from charging a customer twice.

Learn the essential patterns and practices for building large-scale React applications that are maintainable and performant.

Master the new App Router in Next.js 14 with server components, streaming, and advanced patterns.

Discover battle-tested architecture patterns for building robust and scalable Node.js backend applications.

Learn advanced techniques to optimize MongoDB queries, indexes, and schema design for maximum performance.

Master Docker for modern application deployment with practical examples and production-ready configurations.

Deep dive into PostgreSQL performance tuning with indexing strategies, query plans, and optimization techniques.

Build robust CI/CD pipelines using GitHub Actions for automated testing, building, and deployment.

Master advanced TypeScript patterns including generics, utility types, and type-safe design patterns.

Learn how to design clean, intuitive, and scalable REST APIs following industry best practices.

Configure Nginx for production with SSL, load balancing, caching, and security best practices.