Backend Development

The backend is where a product's rules live. It decides who can do what, validates every input, coordinates the database, calls third-party services, and returns responses that clients trust. Users never see it directly, but every bug, slowdown, and outage they feel usually starts there.

This hub focuses on building server applications: choosing a framework, structuring code, talking to databases through an ORM, handling errors, accepting files, and taking payments. The contracts your backend exposes live in APIs & Integration, and asynchronous work lives in Messaging & Event Streaming.

TL;DR

• Pick a framework your team can operate, not the fastest benchmark. Ecosystem, hiring, and tooling matter more.
• Keep business logic out of route handlers. Handlers parse input and call services; services hold the rules.
• Validate at the boundary and never trust client input.
• Use an ORM for productivity, SQL for hard queries. Know what your ORM generates.
• Handle errors deliberately — expected failures return clear responses; unexpected ones get logged with context.
• Hand anything slow to a queue. Requests should finish in milliseconds, not minutes.

Anatomy of a Backend Request

Featured Topics

Node.js & TypeScript

• Express — The minimal, ubiquitous Node.js framework
• NestJS — Structured, Angular-style architecture for Node
• Prisma — Type-safe database access for TypeScript

Python

• FastAPI — Async, type-hint-driven APIs with automatic docs
• Django — The batteries-included framework
• Flask — A micro-framework you assemble yourself

JVM, Ruby, PHP, Elixir & Rust

• Spring Boot — The enterprise Java standard
• Ruby on Rails — Convention over configuration
• Laravel — Modern, expressive PHP
• Phoenix — Real-time web on the BEAM
• Axum — Ergonomic, fast web services in Rust

Cross-Cutting Concerns

• Object-Relational Mapping — ORMs, their trade-offs, and the N+1 problem
• Error Handling — Error types, propagation, and user-facing responses
• File Uploads — Direct-to-storage uploads, validation, and scanning
• Payment Processing — Payment intents, webhooks, and idempotent charges

Choosing a Framework

Common Mistakes

🚫 Fat controllers — Business logic inside route handlers can't be reused or tested in isolation.

🚫 Trusting the ORM blindly — A loop that lazily loads relations fires hundreds of queries. Check the SQL.

🚫 Swallowing errors — catch (e) {} turns a loud bug into silent data corruption.

🚫 Doing slow work in the request — Sending emails or resizing images inline ties up workers. Use background jobs.

🚫 Charging cards without idempotency — A client retry after a timeout double-charges. See Idempotency.

Learning Path

Beginner

Build a CRUD service with one framework, a relational database, and input validation. Learn HTTP status codes and structured error handling.

Intermediate

Add authentication, an ORM with migrations, caching, file uploads, and background jobs. Write integration tests.

Advanced

Integrate payments end to end, instrument the service with logging and tracing, and split responsibilities along domain boundaries.

Related Topics

• APIs & Integration — REST, GraphQL, gRPC, and webhooks
• Databases — The data layer every backend depends on
• Identity & Access Management — Authentication and authorization
• Architecture — Structuring systems beyond a single service