Backend
Backend services and server-side best practices
Best Practices
Hexagonal Architecture (Ports and Adapters)
An architecture that isolates core application logic behind ports, with adapters connecting external concerns like databases and UIs, so the core stays independent of technology.
by Alistair CockburnDomain-Driven Design (DDD)
A software design approach that models complex business domains in code, using a shared language and bounded contexts to align software structure with the business it serves.
by Eric EvansModular Monolith
An architecture that keeps a single deployable application but enforces strong internal module boundaries, capturing many microservices benefits without distributed-system complexity.
by ThoughtWorksPatterns
Object Pool
Reuses a set of pre-initialized, expensive-to-create objects from a managed pool instead of creating and destroying them on demand, improving performance.
Front Controller
Channels all incoming requests through a single handler that centralizes cross-cutting concerns like routing, authentication, and logging before dispatching to handlers.
Read-Through Cache
A caching strategy where the cache itself loads missing data from the backing store on a miss, so application code reads only from the cache.
Write-Through Cache
A caching strategy where every write goes to the cache and the backing store synchronously, keeping the two consistent at the cost of write latency.
Write-Behind Cache
A caching strategy where writes update the cache immediately and are flushed to the backing store asynchronously, maximizing write throughput at the cost of durability.
Refresh-Ahead Cache
A caching strategy that proactively reloads hot entries before they expire, so reads of popular keys never pay miss latency.
Command Query Responsibility Segregation (CQRS)
Separates the write model that handles commands from the read model that serves queries, letting each be optimized, scaled, and evolved independently.
Event-Driven Architecture
An architectural style where components communicate by producing and reacting to events, enabling loose coupling, asynchronous flow, and independent scaling.
Idempotent Writer
A pattern that makes repeated writes safe by ensuring duplicate operations produce the same result, essential for at-least-once delivery and retries.
Tutorials
Migrating from Express to Fastify
Step-by-step tutorial for migrating a Node.js Express application to Fastify for better performance
Implementing Redis Caching in Node.js
Add Redis caching to your Node.js application for improved performance
Real-time Communication with WebSockets
Implement real-time features using WebSockets
Checklists
API Modernisation Checklist
Checklist for modernizing and versioning APIs
Node.js Runtime Upgrade Checklist
Checks for upgrading a Node.js application across major LTS versions, covering dependencies, deprecations, and ESM changes.
Go Service Modernization Checklist
Modernize a Go service for production: modules, context propagation, observability, and idiomatic error handling.
Technology Stacks
MERN Stack
MongoDB, Express.js, React, Node.js - Full-stack JavaScript solution
MEAN Stack
MongoDB, Express.js, Angular, Node.js - Enterprise JavaScript stack
LAMP Stack
Linux, Apache, MySQL, PHP - Classic web development stack
T3 Stack
Next.js, TypeScript, Tailwind, tRPC, Prisma - Type-safe full-stack
PERN Stack
PostgreSQL, Express.js, React, Node.js - Relational DB full-stack
Django HTMX Stack
Django, HTMX, Alpine.js - Modern Python web stack
Rails Hotwire Stack
Ruby on Rails, Hotwire, Turbo - Rails 7+ modern approach
Phoenix LiveView Stack
Elixir, Phoenix, LiveView - Real-time without JavaScript
Go Microservices Stack
Go, gRPC, Kubernetes, PostgreSQL - High-performance services
Supabase Stack
Supabase, Next.js, Tailwind - Open source Firebase alternative
Spring Cloud Stack
Spring Boot, Spring Cloud, Kubernetes - Enterprise Java
.NET Azure Stack
ASP.NET Core, Azure Services, SQL Server - Microsoft ecosystem
LEMP
A classic web stack of Linux, Nginx, MySQL, and PHP that serves dynamic sites with high concurrency and low overhead.
Laravel + Vue
A PHP fullstack pairing the Laravel framework with a Vue front end, often via Inertia, for productive, full-featured web applications.
Rails + Hotwire
A server-driven Ruby on Rails stack using Hotwire (Turbo and Stimulus) to build reactive web apps with minimal custom JavaScript.
Django + React
A decoupled stack with a Django REST backend and a React front end, separating API and UI for flexible, scalable web applications.
Phoenix LiveView
An Elixir stack using Phoenix LiveView to build real-time, server-rendered interactive UIs over WebSockets with little JavaScript.
ASP.NET + Blazor
A .NET stack pairing ASP.NET Core with Blazor to build interactive web UIs in C#, sharing code across server and client.
Spring Boot + Thymeleaf
A Java stack pairing Spring Boot with the Thymeleaf template engine for server-rendered web applications with robust enterprise tooling.
FastAPI + React
A modern Python stack with a FastAPI backend and a React front end, joining high-performance async APIs to a rich interactive UI.
Elixir + Phoenix
A backend-focused web stack using Elixir on the BEAM with the Phoenix framework for highly concurrent, fault-tolerant web services.
HTMX + Go
A hypermedia-driven stack pairing HTMX with a Go backend to build interactive web apps using HTML over the wire and minimal JavaScript.
Django + DRF
A Python backend stack combining Django with Django REST Framework to build secure, well-structured REST APIs and admin-driven apps.
Spring Boot Enterprise Stack
Java backend stack built on Spring Boot with PostgreSQL and Redis for production REST services and enterprise applications.
.NET Web API Stack
Modern C# backend stack using ASP.NET Core, Entity Framework Core, and SQL Server or PostgreSQL for high-performance cross-platform services.
FastAPI + SQLAlchemy Stack
Async Python backend stack using FastAPI, SQLAlchemy, and PostgreSQL for high-performance, type-hinted REST and ML-serving APIs.
Go + Gin + Postgres Stack
Lightweight Go REST backend using the Gin web framework with PostgreSQL and Redis for fast, simple, high-throughput HTTP APIs.
Node + Express + Mongo Stack
JavaScript backend stack using Node.js, Express, and MongoDB for flexible, schema-light REST APIs and rapid prototyping.
NestJS + Postgres Stack
Structured TypeScript backend stack using NestJS with PostgreSQL and an ORM for scalable, modular, enterprise-grade Node.js services.
Rails API Stack
Ruby on Rails backend in API mode with PostgreSQL and Redis for convention-driven, fast-to-build REST services and SaaS backends.
Quarkus Cloud-Native Java Stack
Cloud-native Java backend using Quarkus with GraalVM native compilation and PostgreSQL for fast-starting, low-memory containerized services.
Ktor Kotlin Backend Stack
Asynchronous Kotlin backend using the Ktor framework with PostgreSQL and coroutines for lightweight, idiomatic, non-blocking services.
Rust Axum/Actix Backend Stack
High-performance, memory-safe Rust backend using Axum or Actix with PostgreSQL for low-latency, resource-efficient services.
Phoenix Elixir Stack
Concurrent Elixir backend using the Phoenix framework on the BEAM VM with PostgreSQL for fault-tolerant, real-time, highly concurrent services.
Vue + Laravel SPA
A Vue single-page frontend talking to a Laravel JSON API, a common PHP full-stack pairing for content-heavy and SaaS applications.
React + Spring Boot
A React frontend backed by a Java Spring Boot REST API, a workhorse enterprise stack for large, long-lived business applications.
Angular + Spring Boot
An Angular frontend over a Spring Boot Java backend, a strongly opinionated, fully typed enterprise stack favored by large IT organizations.
React + Django REST Framework
A React frontend consuming a Django REST Framework API, a productive Python full-stack for data-rich and ML-adjacent web applications.
Express + React + Postgres
A classic JavaScript full stack: an Express REST API on Node.js, a React frontend, and a PostgreSQL database, flexible and widely understood.
Fastify + Prisma
A high-performance Node.js backend using Fastify with schema-based validation and Prisma ORM over PostgreSQL, built for low-overhead, type-safe APIs.
AdonisJS Full-Stack
An opinionated, batteries-included Node.js MVC framework with its own ORM, auth, and validation, bringing a Laravel-like experience to TypeScript.
Vapor Swift Server
A server-side Swift web framework using async/await and a typed ORM, letting iOS-focused teams build backends in the same language as their apps.
Play Framework (Scala)
A reactive, stateless web framework on the JVM written for Scala (and Java), built on Akka for non-blocking, high-throughput web applications and APIs.
Ktor + Exposed
A lightweight, coroutine-based Kotlin web framework paired with the Exposed SQL library, for idiomatic, asynchronous Kotlin backends and APIs.
Rocket (Rust) Stack
An ergonomic, type-safe Rust web framework with compile-time route checking and request guards, paired with a database for fast, safe backends.
Axum + SQLx (Rust)
A modern async Rust backend built on the Tokio runtime with the Tower middleware ecosystem and compile-time-checked SQL via SQLx.
Symfony + API Platform
A robust PHP stack using the Symfony framework and API Platform to generate REST and GraphQL APIs from data models with documentation and standards built in.
ASP.NET MVC + EF Core
Microsoft's server-rendered web stack using ASP.NET Core MVC and Entity Framework Core over SQL Server or Postgres, for robust enterprise web applications.
FastAPI + HTMX
A modern Python stack pairing the async FastAPI framework with HTMX to build dynamic, server-rendered web apps with little custom JavaScript.
Gin + GORM
A fast, lightweight Go web stack pairing the Gin HTTP framework with the GORM ORM, popular for high-performance REST APIs and backend services.
Echo + Ent
A performant Go web stack combining the Echo framework with Ent, an entity framework that generates type-safe, graph-aware data access code from schemas.
Supabase Realtime Stack
A realtime application stack built on Supabase, streaming Postgres changes, broadcast messages, and presence to clients over WebSockets atop row-level security.
Firebase Realtime Stack
A serverless realtime app stack on Google Firebase using Cloud Firestore and the Realtime Database, with Auth, Cloud Functions, and offline sync for mobile and web.
Salesforce Platform
An enterprise low-code and pro-code application platform on Salesforce, using Apex, Lightning Web Components, and the data model to extend CRM and build business apps.
Benchmarks
SPECjbb 2015
Java server benchmark modeling a supermarket company's transaction processing to measure JVM and server-side Java throughput and latency.
TechEmpower Web Framework Benchmarks
Open benchmark suite comparing web frameworks and platforms across standardized request types like JSON, single-query, and plaintext throughput.
wrk HTTP Benchmark
Modern, multithreaded HTTP load-testing tool that generates high request volume from a single machine and reports throughput and latency distribution.
ApacheBench (ab)
Simple, ubiquitous command-line HTTP benchmarking tool for quick single-endpoint throughput and latency measurement, bundled with Apache.
SPECjbb 2015
Standard Java server benchmark modeling a supermarket company's business logic to measure throughput and critical response-time performance.