Backend
Idempotency Keys in Practice: Making Retries Safe
How to design and implement idempotency keys so retried requests never double-charge, double-send, or double-create resources.
·5 min read
Tags
typescript
66 articles
Engineering
Cancellation Patterns in TypeScript: Taming AbortController
Why most async TypeScript code ignores cancellation entirely, and how to build composable, leak-free cancellation with AbortController.
·4 min read
Engineering
TypeScript Template Literal Types: Building Expressive, Type-Safe APIs
Use TypeScript template literal types to encode event names, route patterns, and permission sets directly into your type system — no runtime checks, no string drift.
·4 min read
Architecture
Evolving Event Schemas Without Breaking Consumers
How to add fields, rename properties, and restructure events in async systems without coordinating deployments or silently breaking downstream consumers.
·4 min read
Backend
Request Coalescing: Preventing the Thundering Herd in Node.js
When a cache entry expires under high traffic, dozens of requests race to rebuild it simultaneously — here's how inflight request deduplication collapses that stampede into a single upstream call.
·4 min read
Backend
Full-Text Search in Postgres: Skip Elasticsearch for Most Use Cases
Postgres has a powerful built-in full-text search engine using tsvector, tsquery, and GIN indexes — no Elasticsearch cluster required for most applications.
·4 min read
Backend
Streaming Large Datasets in Node.js: Backpressure and Async Generators
Stop loading entire result sets into memory: how Node.js streams and async generators let you process millions of records without blowing the heap.
·4 min read
Backend
Distributed Locks: Coordinating Work Across Multiple Nodes
Stop racing conditions in distributed systems: a practical guide to implementing distributed locks with Redis and PostgreSQL advisory locks in Node.js.
·5 min read
Engineering
TypeScript's satisfies Operator: Type Safety Without Losing Inference
TypeScript's satisfies operator validates that a value matches a type while preserving literal inference — here's why that distinction matters and where to apply it.
·4 min read
Backend
Type-Safe Event Emitters in TypeScript
Replace Node's stringly-typed EventEmitter with a generic typed alternative that catches event name typos and payload mismatches at compile time.
·4 min read
Backend
Durable Execution: Building Long-Running Workflows That Survive Restarts
Why job queues and database state machines break down for complex multi-step processes, and how durable execution with Temporal gives you workflows that survive crashes, retries, and deployments.
·5 min read
Backend
Async Concurrency Control in Node.js: Semaphores, Throttling, and Backpressure
Unbounded Promise.all is a silent OOM killer — here's how to build semaphores, throttled queues, and stream backpressure into your Node.js applications.
·4 min read
Backend
The DataLoader Pattern: Eliminating N+1 Queries Without an ORM
N+1 isn't an ORM problem — learn how to implement the DataLoader batching pattern in TypeScript to collapse redundant data fetches across any data source, including microservices.
·4 min read
Architecture
The Transactional Outbox Pattern: Solving Dual-Write in Distributed Systems
How the transactional outbox pattern eliminates the dual-write problem and guarantees reliable event publishing without coupling your database to your message broker.
·5 min read
Backend
Request Context Without Prop Drilling: AsyncLocalStorage in Node.js
Use AsyncLocalStorage to propagate request-scoped context — trace IDs, user sessions, tenant data — through async call stacks without threading values through every function signature.
·4 min read
Engineering
TypeScript Branded Types: Compile-Time Domain Modeling
Eliminate a whole class of runtime bugs by teaching TypeScript's type system the difference between a UserId and an OrderId — even when both are strings under the hood.
·5 min read
Backend
Contract-First API Design with OpenAPI and TypeScript
Stop letting your API spec drift from your implementation — define the contract first, generate types for both sides, and let the compiler catch the gaps.
·4 min read
Backend
Composable Middleware Pipelines in TypeScript
Stop bolting middleware onto frameworks and start building type-safe, composable pipeline primitives you can test in isolation and reason about at a glance.
·4 min read
Engineering
Runtime Type Safety with Zod: Validating at Every Boundary
TypeScript's type system stops at compile time — Zod closes the gap by validating data at the runtime boundaries where it actually matters.
·4 min read
Frontend
React Server Actions: Patterns, Pitfalls, and Production Use
Server Actions bring form handling and mutations back to the server in Next.js — here's how to use them well, what to avoid, and how to build patterns that scale.
·4 min read
Frontend
Finite State Machines for Complex UI Logic in TypeScript
Replace boolean flag spaghetti with finite state machines: a TypeScript-first approach to UI states that makes impossible states impossible by construction.
·4 min read
Backend
Worker Threads in Node.js: Offloading CPU-Bound Work Without Blocking
Learn how to use Node.js worker threads to handle CPU-intensive tasks without blocking the event loop, with thread pooling and type-safe messaging patterns.
·5 min read
Engineering
Error Handling in TypeScript: Patterns That Scale
Move beyond try-catch soup: discriminated unions, Result types, and error boundaries that make TypeScript codebases more reliable and maintainable.
·3 min read
Backend
Building Scalable APIs with Next.js Route Handlers
A comprehensive guide to designing and building scalable, production-ready APIs using Next.js Route Handlers with TypeScript, validation, and error handling patterns.
·2 min read
Engineering
TypeScript Patterns for Large Codebases
Advanced TypeScript patterns I rely on daily — discriminated unions, branded types, the builder pattern, and utility types that make large codebases safer and more maintainable.
·3 min read
Engineering
Dependency Injection Patterns in TypeScript Applications
Implement dependency injection in TypeScript using constructor injection, factory functions, DI containers, and module-level composition patterns that improve testability and decouple components without framework lock-in.
·4 min read
Tutorials
End-to-End Testing Strategies with Playwright and TypeScript
Build reliable end-to-end test suites with Playwright using page object models, test isolation, network interception, visual regression testing, and CI integration patterns that catch real user-facing bugs without flaky failures.
·3 min read
Backend
Real-Time Data Pipelines with Apache Kafka and TypeScript
Build real-time data pipelines using Apache Kafka with TypeScript consumers and producers, covering partitioning strategies, consumer groups, exactly-once semantics, and dead letter queues for reliable event streaming.
·3 min read
Tutorials
Building CLI Tools with TypeScript and Commander.js
Create professional command-line tools with TypeScript that feature argument parsing, interactive prompts, progress indicators, and structured output, using Commander.js and supporting libraries for a polished developer experience.
·4 min read
Backend
Building Type-Safe GraphQL APIs with Code Generation
A practical guide to achieving end-to-end type safety in GraphQL applications using schema-first code generation, covering resolver typing, client-side query types, and eliminating runtime type mismatches between frontend and backend.
·3 min read
DevOps
Infrastructure as Code with Pulumi: TypeScript for Cloud Resources
A hands-on guide to managing cloud infrastructure with Pulumi and TypeScript, covering resource composition, state management, secrets handling, and testing infrastructure code with real programming language features.
·4 min read
Tutorials
Building a Full-Stack Type-Safe API with tRPC and Next.js
A complete tutorial on building end-to-end type-safe APIs using tRPC with Next.js App Router, covering router setup, middleware chains, input validation, and real-time subscriptions.
·5 min read
DevOps
Infrastructure as Code with Pulumi: Beyond Terraform's Declarative Model
A practical comparison of Pulumi and Terraform for infrastructure as code, demonstrating how general-purpose languages enable abstractions, testing, and composition patterns that HCL cannot express.
·5 min read
Tutorials
Building a Real-Time Notification System from Scratch
Build a production-ready real-time notification system using Server-Sent Events and WebSockets with TypeScript, covering message delivery guarantees, client reconnection, notification persistence, and read-state tracking.
·4 min read
Architecture
Hexagonal Architecture: Ports and Adapters in Practice
Implement hexagonal architecture with concrete TypeScript examples showing how ports define business contracts, adapters handle infrastructure, and dependency inversion keeps the domain layer testable and framework-independent.
·5 min read
Artificial Intelligence
Prompt Engineering Patterns for Production Applications
Systematic prompt engineering patterns for production LLM applications including structured output extraction, chain-of-thought reasoning, few-shot calibration, prompt versioning, and automated evaluation pipelines.
·5 min read
Tutorials
Building a CLI Tool with Node.js from Scratch
Step-by-step tutorial for building a professional CLI tool in Node.js with argument parsing, interactive prompts, colored output, progress indicators, configuration files, and cross-platform publishing to npm.
·5 min read
Engineering
Property-Based Testing: Finding Bugs Your Unit Tests Miss
Learn how property-based testing generates hundreds of random inputs to verify code invariants, catching edge cases that hand-written example tests overlook with practical patterns in TypeScript using fast-check.
·5 min read
Tutorials
Building a Type-Safe Form Library from Scratch
Walk through building a type-safe form library in TypeScript with runtime validation, field-level error tracking, dirty state management, and a composable API that catches form errors at compile time.
·5 min read
Architecture
Applying Clean Architecture Principles to Real-World Applications
Implement clean architecture patterns that separate business logic from infrastructure concerns, making applications testable, maintainable, and adaptable to changing requirements or technology choices.
·4 min read
Tutorials
Building a Type-Safe API Client Generator from OpenAPI Specs
Build a code generator that reads OpenAPI specifications and produces fully typed TypeScript API clients with request validation, error handling, and automatic type inference.
·5 min read
Engineering
Designing Effective Error Boundaries in Complex Applications
Build robust error boundary strategies that catch failures gracefully, provide meaningful fallbacks, report actionable diagnostics, and prevent one broken component from crashing the entire application.
·4 min read
Tutorials
Building a Markdown Parser from Scratch in TypeScript
Walk through building a Markdown parser step by step, covering lexical analysis, AST construction, and HTML rendering to understand how text processing engines work under the hood.
·5 min read
Engineering
Building a Custom ESLint Plugin
How to build custom ESLint rules for your team's conventions — covering AST selectors, rule testing, auto-fixers, and publishing a shared plugin that enforces patterns your default linter cannot catch.
·4 min read
Tutorials
Building a GraphQL Server From Scratch
A step-by-step tutorial for building a GraphQL server with TypeScript — covering schema design, resolvers, dataloaders for N+1 prevention, authentication, error handling, and deployment patterns.
·4 min read
Engineering
Understanding Compiler Design for Better Code
A developer-friendly introduction to compiler fundamentals — covering lexing, parsing, ASTs, and code generation with practical examples that help you write better code, build tooling, and understand language features.
·4 min read
Tutorials
Building a Rate Limiter From Scratch
A step-by-step tutorial for building rate limiters using the token bucket, sliding window, and fixed window algorithms — with TypeScript implementations, Redis integration, and production deployment patterns.
·4 min read
Architecture
The Saga Pattern for Distributed Transactions
How to implement the saga pattern to manage distributed transactions across microservices — comparing orchestration versus choreography approaches with practical TypeScript examples and compensation logic.
·5 min read
Tutorials
Building an Event-Driven Microservice with Node.js
A step-by-step tutorial for building an event-driven microservice using Node.js, RabbitMQ, and TypeScript — covering event publishing, consumption, dead letter queues, and idempotent processing.
·5 min read
Architecture
Hexagonal Architecture in Practice
How to implement hexagonal architecture (ports and adapters) in a real application — separating business logic from infrastructure with clear boundaries, dependency inversion, and testable core domains.
·5 min read
Tutorials
Building a URL Shortener from Scratch
A step-by-step tutorial for building a URL shortener service with short code generation, redirect handling, click analytics, and rate limiting — covering the full system design from database schema to API.
·5 min read
Artificial Intelligence
Building a Recommendation Engine: The Basics
A practical introduction to recommendation systems — covering collaborative filtering, content-based filtering, and hybrid approaches with TypeScript implementations developers can understand and adapt.
·4 min read
Tutorials
Building a Browser Extension from Scratch
A step-by-step tutorial for building a Chrome/Firefox browser extension using TypeScript — covering the manifest file, content scripts, background service workers, popup UI, and messaging between contexts.
·5 min read
Tutorials
Building a Real-Time Dashboard with WebSockets
A step-by-step tutorial for building a live-updating dashboard using WebSockets — covering server setup, client connection management, data streaming, reconnection logic, and scaling considerations.
·4 min read
Artificial Intelligence
Reinforcement Learning Basics for Software Developers
A practical introduction to reinforcement learning concepts — agents, environments, rewards, and policies — with TypeScript examples that map RL ideas to problems developers already understand.
·4 min read
Architecture
Building a Plugin Architecture in TypeScript
How to design a plugin system that lets users extend your application without modifying its core — covering plugin interfaces, lifecycle hooks, dependency resolution, and sandboxing.
·5 min read
Engineering
Async Iteration Patterns in JavaScript and TypeScript
A deep dive into async iterators and generators in JavaScript — covering for-await-of loops, async generator functions, backpressure handling, and real-world streaming patterns.
·4 min read
Tutorials
Building a Full-Text Search Engine from Scratch
How full-text search engines work internally — covering tokenization, inverted indexes, TF-IDF scoring, and building a working search engine in TypeScript step by step.
·5 min read
Engineering
Property-Based Testing in TypeScript with Fast-Check
How property-based testing finds edge cases your unit tests miss — a practical guide using fast-check to generate thousands of test inputs and verify invariants automatically.
·4 min read
Tutorials
Migrating from JavaScript to TypeScript Incrementally
A step-by-step guide for migrating existing JavaScript projects to TypeScript without stopping feature development — covering configuration, strict mode adoption, and team workflows.
·4 min read
Frontend
Building Reusable React Hooks: Patterns and Anti-Patterns
How to design custom React hooks that are truly reusable — covering composition patterns, testing strategies, state encapsulation, and common anti-patterns to avoid.
·5 min read
Tutorials
Building a CLI Tool with Node.js: From Basics to Distribution
A complete guide to building, testing, and distributing a Node.js CLI tool — covering argument parsing, interactive prompts, output formatting, and npm publishing.
·6 min read
Engineering
Functional Programming Patterns in TypeScript
Practical functional programming patterns for TypeScript that improve code clarity without requiring a complete paradigm shift.
·5 min read
Engineering
TypeScript Generics: From Confusion to Confidence
A practical guide to TypeScript generics that takes you from basic type parameters to advanced conditional types and utility patterns.
·4 min read
DevOps
Environment Variable Management Done Right
Stop scattering process.env calls across your codebase — validate, type, and centralize environment configuration for safer deployments.
·3 min read
Engineering
Dependency Injection in Practice
Dependency injection doesn't require a framework or decorators — here's how to apply it in TypeScript with simple patterns that make code testable and flexible.
·3 min read