Guides, tutorials, and comparisons to help you build better backend applications.
Using IaC tools to unlock productivity and cost benefits.
A look at AWS CloudFormation and other alternatives
A look at Azure Resource Manager and other alternatives
Infrastructure from Code vs. Infrastructure as Code, compared
A look at Google Cloud Deployment Manager and other alternatives
The case for and against IaC in 2026
What is IaC and when is it appropriate?
Managing dev, staging, and production without infrastructure duplication
A practical comparison of the two major IaC tools after the fork, and what comes next
A look at key features, strengths, and weaknesses
A look at Terraform's viability in 2026 and beyond
Recovering from partial applies and understanding why there's no rollback
Should you use Terraform Cloud or is there a better alternative?
Detecting and managing infrastructure drift in Terraform
Use Cases, Advantages and Drawbacks
Diagnosing and fixing phantom diffs in Terraform
A look at advantages, risks, and challenges
Fixing state conflicts when Terraform tries to create existing resources
What causes state locks and how to resolve them
A look at Features, Limitations, and Alternatives
Navigate the expansive world of cloud providers and services.
A practical comparison of the best AWS App Runner alternatives for deploying containerized apps in 2026.
A brief intro to cloud providers
What's the difference anyway?
What BaaS is, the modern provider landscape, and how teams plan the eventual exit
Understanding cost optimization to control your cloud spending
Scheduled tasks without EventBridge configuration
Production deployment options that skip container orchestration
From 100 lines of HCL to two lines of TypeScript
Every option from EC2 to Lambda, ranked by effort and operational cost
Choosing the right AWS container deployment model
AWS App Runner is moving to maintenance mode. Here's what changed, what it means for your production apps, and what to do next.
Heroku is moving to maintenance mode. Here's what changed, what it means for your production apps, and what to do next.
Compute Engine, Cloud Run, Cloud Functions, and Kubernetes Engine compared
A practical comparison of the best Heroku alternatives for deploying backend applications in 2026.
Heroku moved to maintenance mode. Here's where teams are migrating and why.
What happens between git push and running on Fargate
A developer's guide to the AWS deployment landscape
A developer's guide to the Google Cloud deployment landscape
Understanding the cloud service models, where they fit, and where the model is heading next
Understanding if IaaS is the right choice
Multi-service deployment without the infrastructure configuration
A practical guide to PaaS, the modern provider landscape, and where the model is heading
A look at Vercel and its key use cases and important limitations
From TypeScript to a running AWS deployment in under 10 minutes
From TypeScript to a running GCP deployment in under 10 minutes
Understanding cloud infrastructure and its uses.
Kubernetes Cheet SheetA handy reference for common k8s operations with kubectl
Developer portals vs developer platforms
A practical guide to automating cloud infrastructure for backend teams
A practical decision framework for backend teams
Standardized paths to production without the platform engineering overhead
Powering Intensive Workloads with Google Cloud
What it takes to build a platform, and when buying makes more sense
Container deployment without the operational overhead
The layers of complexity behind container orchestration
What you actually pay to run a Kubernetes cluster
Container orchestration alternatives beyond Kubernetes
An introduction to the basics of Kubernetes
Container orchestration solves real problems at scale, but most teams pay for complexity they don't need
Navigating the platform engineering landscape in 2026
The default stack AI agents build, and what happens when you remove it
What is Serverless and should you use it when building microservices?
What is Serverless and should you use it when building microservices?
Resources for building great backend systems.
Everything you need to know about the different types of APIs
A practical guide to choosing the right platform for building and running backend services
API-Driven Backend vs. Backend-in-Frontend vs. Cloud Functions
Everything you need to know about tracing TypeScript backend applications
A practical guide to choosing the right platform for your backend
Comparing instrumentation approaches, tracing backends, and observability platforms
Find the exact database query, service call, or external API slowing down your endpoints
Follow requests across service boundaries without losing context
From zero visibility to full request tracing without instrumentation code
A practical guide to designing, building, and operating event-driven systems
SNS, SQS, dead-letter queues, IAM policies, or one line of TypeScript
Choosing the right API architecture for your backend
Choosing a data format for inter-service communication
We take a look at CI/CD for microservices development
A look at building microservices applications
A look at the strengths and weaknesses of monoliths
What if the infrastructure just followed from the code?
Traces, metrics, and instrumentation from scratch
Speed up development and testing with Preview Environments
Pub/Sub concepts, cloud differences, and tooling
We take a look at using REST for backend communication
See exactly what happens when a request hits your server
The three pillars of observability and how they work together
We tested what Claude Code, Cursor, and Copilot reach for
We take look at YAML and its challenges
Resources for building great backend applications with TypeScript.
Comparing the top frameworks for building TypeScript backends
Which Node.js framework suits your project best?
Which ORM is right for your TypeScript project?
Useful resources for building Go applications.
Go Modules Cheet SheetA handy reference for common operations with Go modules
Compare instrumentation approaches and tracing backends for Go
Find the exact query, goroutine, or service call slowing down your endpoints
Add end-to-end request tracing to your Go backend
Which framework suits your project best?
Using Go for microservices applications
Which ORM is suitable for your project?
From zero to production tracing with the OTel Go SDK
Migrate from managed platforms to your own AWS or GCP account.
Move from Amplify's managed services to infrastructure you fully control
Move from App Runner to ECS on your own AWS account with a simple deployment workflow.
Move from Appwrite to your own AWS account for more control
Move from Appwrite to your own Google Cloud account
Move from Convex to your own AWS account for infrastructure ownership
Move from Convex to your own Google Cloud account
Move from Firebase to your own AWS account for SQL databases, lower costs, and more control
Stay on Google Cloud but move from Firestore to PostgreSQL for better data modeling
Move from Fly.io to your own AWS account for more control
Move from Fly.io to your own Google Cloud account
Move from Heroku to your own AWS account with a simple deployment workflow
Move from Heroku to your own Google Cloud account with a simple deployment workflow
Move from Railway to your own AWS account for infrastructure ownership
Move from Railway to your own Google Cloud account
Move from Render's managed platform to your own AWS account
Move from Render's managed platform to your own Google Cloud account
Move your backend to your own AWS account for more control and lower costs at scale
Move your backend to your own Google Cloud account for more control and lower costs at scale
Move your backend off Vercel and onto your own AWS account
Move your backend off Vercel and onto your own Google Cloud account
What a backend team's week looks like once agents write most of the code: specifying instead of typing, running the backlog in parallel, reviewing by running, and a platform team that sets rules instead of approving changes.
How deterministic provisioning, central guardrails, and a human at the merge let agents ship to your cloud without improvising infrastructure.
Why mocks let backend bugs through, the options for giving agents a working database and queues, and why isolation matters as much as the infrastructure itself.
How the two relate, where CI/CD strains once agents are producing changes, and why a factory uses your pipeline rather than replacing it.
The components of an AI software factory and how a change flows through them, from intake to a deploy on your own cloud, with the control plane kept separate from the loop agents work in.
No single product is a complete AI software factory yet. The layers one is built from, the tools that cover each, and how to decide where to start.
How to put the stages around your coding agent so a task goes from a request to a change deployed on your own cloud, starting from a service you already run.
The system that takes a task from an AI coding agent and carries it all the way to software running on your own cloud. What it is, one feature built through it, and what it costs.
Measured token spend across Encore, Express, Fastify, Hono, and NestJS when Claude Code builds the same realistic backend project.
Encore came in at $6.29 of token spend across three benchmark runs. NestJS came in at $12.69 for the same work with fewer passing tests.
We benchmarked Claude Code on five TypeScript backends. Cursor uses the same models, so the framework ranking and the numbers behind it port over directly.
We benchmarked Claude Code on five TypeScript backend frameworks. Only one shipped production-ready code on the first pass, and only one had a CLAUDE.md and MCP server in the box.
Five frameworks, the same coding agent, the same tests, and a 36-check production-readiness rubric. Which framework ships code an AI agent can build production-ready in one pass?
Hono ran cheapest in our AI-readiness benchmark and collapsed worst when the test suite started probing for production-readiness.
Fastify was the closest non-Encore result in our AI-readiness benchmark, and reaching that result still cost about twice as many tokens.
Claude Code on NestJS cost about twice as many tokens as the same agent on Encore, and shipped fewer working production-readiness checks.
What Claude Code shipped when we gave it the same backend tasks on Express and on Encore.
What a gateway does, the patterns worth knowing, and when a small system is better off without one
Synchronous calls versus events, the tradeoffs of each, and the reliability work that makes either one hold up
The signals that it's time, and a strangler-fig playbook for extracting the first service without a rewrite
How to structure many services in one repository, share code without hidden coupling, and decide between monorepo and polyrepo
Service boundaries, a database per service, sync vs async calls, contracts, tracing, and independent deploys, with the failure each practice prevents
Why teams are consolidating, how AI agents change the tradeoff, and a framework for deciding
Evaluating NestJS, Encore, Moleculer, Fastify, and Hono for distributed systems
Patterns, communication, deployment, and avoiding distributed-monolith mistakes
Where to deploy when Vercel's pricing, limits, or scope stop fitting
What to use when CloudFormation limits and construct abstractions get in the way
How to organize modules, services, and shared code so the codebase scales
JWT, Passport strategies, guards, and how to wire it all together
Transports, patterns, deployment, and when a simpler approach makes sense
What to use when you've outgrown Google's BaaS
What to use when you need more infrastructure control than a shared platform
What to use when you've outgrown shared platform infrastructure
What to use now that SST is in maintenance mode
TypeScript backend frameworks for when you need more than Bun performance
What to use when you want infrastructure without separate config programs
What to use when HCL and state files aren't working for your team
What to use when you've outgrown Backend-as-a-Service
What to use when you want more control over your infrastructure
Understanding Anthropic's protocol for connecting AI models to tools and data
Understanding asynchronous messaging patterns for backend systems
A practical guide to choosing a Node.js framework for your backend
Go HTTP routers and frameworks beyond chi
Modern TypeScript frameworks for teams moving beyond Express
TypeScript backend frameworks beyond JSON Schema validation
TypeScript backend frameworks that skip the boilerplate
What to use when you need more than an edge-first framework
A practical comparison of pgvector, Pinecone, Qdrant, Weaviate, Milvus, Chroma, and LanceDB
Which frameworks produce the best results when AI writes the code
From the standard library to full-featured frameworks
A practical guide to choosing the right framework for your project
Write infrastructure in TypeScript, Python, or Go on top of the Terraform engine
Where to look when Crossplane's Kubernetes dependency or operational weight stops fitting
A practical, audience-segmented decision on when Terraform earns its place and when it's overhead
The real options for TS and Node engineers who don't want to write HCL
A step-by-step migration path that imports existing resources instead of recreating them
What real module boundaries look like, how to keep them from rotting, and exactly what you trade against microservices
Three TypeScript frameworks for three different positions on the spectrum
Three popular Go web frameworks compared on performance, DX, and ecosystem
Three approaches to TypeScript database access, which fits your project
Comparing two Heroku-style platforms, pricing, developer experience, and limits
Comparing an opinionated framework to a fast, schema-first one, plus a third option
Comparing the two most common Node.js backend frameworks, and a third option worth knowing
Two approaches to TypeScript ORMs compared, and when to skip the ORM layer
Two lightweight TypeScript frameworks compared, and what to use when you need more
Comparing Bun-native and infrastructure-aware TypeScript frameworks
One database with a vector extension, or two databases each doing one thing well?
When your Postgres can already do vector search, do you need a dedicated service?
Lightweight routing versus a full backend development platform
Express-inspired performance versus infrastructure-from-code
Two approaches to building Go backends, compared side by side
Comparing Go's most popular web framework with an infrastructure-from-code approach
Comparing two approaches to end-to-end type safety
Comparing edge-first and infrastructure-aware TypeScript frameworks
Comparing schema-validated vs infrastructure-aware TypeScript frameworks
Comparing enterprise-grade Node.js frameworks for building backends
Comparing the most popular Node.js framework with a modern alternative
Real languages synthesizing CloudFormation versus HCL and a multi-cloud provider ecosystem
A continuously reconciling control plane inside Kubernetes versus a one-shot CLI apply
A real programming language or an open-source, Terraform-compatible HCL engine
One provisions cloud resources, the other configures machines. Most teams end up running both.
The AWS-committed team's real decision, with the tradeoffs on both sides
HCL and a purpose-built DSL against real programming languages, and how the OpenTofu fork changes the math
Terragrunt is Terraform plus scaffolding. Here's when the scaffolding earns its keep.
ECS, EKS, and Lambda compared, plus the networking, discovery, and CI/CD work that trips teams up
Schemas, resolvers, code-first vs schema-first, and what actually ships
Redis-backed caching with automatic provisioning and type safety
Tool-calling endpoints, conversation storage, and async processing
How to use Neon's serverless PostgreSQL with modern TypeScript backends
Embed documents, store vectors in pgvector, search by meaning, and generate answers with an LLM
From zero to PostgreSQL with automatic provisioning
A practical guide to building distributed systems with type-safe service communication
A practical guide to building type-safe APIs with modern Go tooling
From zero to PostgreSQL with automatic provisioning
Secure your endpoints with JWT, sessions, or API keys
A practical guide to building distributed systems that don't fall apart
Schedule recurring tasks in your backend without external services
A practical guide to building type-safe APIs with modern tooling
Taking backends from Cursor, Claude Code, Copilot, or Codex to AWS and GCP
Infrastructure provisioning from your application code
From local development to production without infrastructure expertise