Skip to content

Back End Development

Jump to bottom
Spinning Idea edited this page Jun 24, 2026 · 5 revisions

Here are the core skillsets required for backend focused development:

Programming Fundamentals

Backend engineering is built on a small set of timeless concepts. Master these once and every framework becomes a different flavor of the same thing.

Core areas:

  • How the internet works: HTTP, DNS, TCP/IP, TLS/SSL
  • Request/Response lifecycle: routing, middleware, handlers, serialization, status codes
  • Data structures & algorithms: arrays, objects, lists, maps, trees, sorting, searching
  • Databases: relational (SQL/PostgreSQL) and NoSQL basics, ACID, indexing, transactions
  • APIs: REST, JSON, OpenAPI/Swagger, gRPC, WebSockets
  • Authentication & authorization: sessions, JWT, OAuth2, RBAC
  • Caching & performance: cache strategies, CDNs, rate limiting
  • Security basics: OWASP Top 10, input validation, CORS, SQL injection, XSS
  • Architecture patterns: MVC, layered architecture, microservices, 12-Factor App
  • DevOps basics: containers, CI/CD, observability, logging

Resources:

JavaScript Fundamentals

Node.js runs the V8 engine outside the browser, enabling JavaScript on the server. Key concepts for backend JavaScript:

  • Event loop & async programming: callbacks, Promises, async/await, non-blocking I/O
  • Modules: CommonJS (require) and ECMAScript Modules (import)
  • Core built-ins: http, fs, path, events, stream, buffer
  • Error handling: try/catch, error-first callbacks, global error handlers
  • TypeScript: static types, interfaces, generics for larger backends

Resources:

JavaScript Libraries and Backend Frameworks (Node, Express, ORMs)

For Node.js backends, the framework choice shapes how the codebase organizes itself over time.

Popular frameworks:

  • Express: battle-tested, largest middleware ecosystem, good for prototypes and simple APIs
  • Fastify: high-performance, schema-based validation (JSON Schema), 3-4x faster than Express in benchmarks
  • NestJS: TypeScript-first, opinionated, enterprise-grade with modules/controllers/services and dependency injection
  • Hono: lightweight, edge-first, works on Cloudflare Workers and Bun
  • Encore.ts: infrastructure-aware framework for distributed systems

Database tooling:

  • ORMs: Prisma, TypeORM, Sequelize, Drizzle
  • Query builders: Knex.js
  • Databases: PostgreSQL (recommended), MySQL, SQLite, MongoDB, Redis

Resources:

Testing and Debugging

Backend testing should emphasize integration tests that exercise real database flows, not just mocked unit tests.

Testing layers:

  • Unit tests: Jest, Vitest, Mocha
  • Integration tests: run the app against a real (or test) database
  • API endpoint tests: Supertest for HTTP assertions
  • API exploration & automation: Postman, Insomnia, Hoppscotch, curl
  • Debugging: Node.js --inspect, Chrome DevTools, VS Code debugger

Jest vs Vitest in 2026:

  • Vitest: faster cold start, native ESM, native TypeScript via Vite, Jest-compatible API
  • Jest: mature ecosystem, still excellent for large existing suites

Resources:

Version Control Systems (Git)

Git is a distributed version control system that stores snapshots of the project over time.

Key concepts:

  • Distributed VCS: every clone is a full backup of history
  • Three states: modified, staged, committed
  • Branching: lightweight branches for feature work, bug fixes, experiments
  • Workflows: GitFlow, GitHub Flow, trunk-based development
  • Collaboration: pull/merge requests, code review, rebasing

Resources:

Build Tools and Task Runners (Vite/Webpack)

For backend JavaScript/TypeScript, build tools handle transpilation, bundling, and task automation.

Tools:

  • Vite: fast dev server, esbuild-based transpilation, primarily frontend but works for backend via vite-node or vitest
  • Webpack: mature bundler with extensive plugin ecosystem
  • esbuild: extremely fast Go-based bundler/transpiler
  • Turbopack/Rolldown: Rust-based next-gen bundlers
  • Task runners: npm scripts, tsx, ts-node, nodemon

Note: Backend code often runs unbundled in development (via tsx/ts-node) and is bundled for deployment.

Resources:

Developer Tools (Postman)

API developer tools are essential for designing, testing, documenting, and monitoring APIs.

Key tools:

  • Postman: API client, collections, environments, automated tests, mock servers, monitors, Postman CLI
  • Insomnia: cross-platform REST/GraphQL client
  • Hoppscotch: open-source web-based API client
  • curl: command-line tool for quick HTTP requests
  • Newman: CLI runner for Postman collections in CI/CD

Postman features:

  • Collections to organize requests
  • Environments and variables for local/staging/prod
  • Pre/post-request scripts and tests
  • Mock servers and API documentation
  • Newman/Postman CLI for CI/CD integration

Resources:

Performance Optimization/Tuning

Most backend performance issues come from a few predictable antipatterns: unindexed queries, N+1 patterns, stateful servers, missing caching, and synchronous slow operations.

Key techniques:

  • Database indexing: index fields you filter, sort, or join on; use EXPLAIN ANALYZE
  • Query optimization: avoid full table scans, N+1 queries, and inefficient joins
  • Connection pooling: manage database connections efficiently
  • Caching: Redis, Memcached, layered caches (L1 in-process + L2 Redis)
  • Asynchronous processing: move slow work (emails, PDFs, external APIs) to background jobs
  • Stateless design: keep session/state in external stores (DB/cache), not server memory
  • Rate limiting: protect APIs from abuse
  • Monitoring: profile before optimizing, track slow queries

Resources:

Continuous Integration and Deployment (Pipelines and GitHub Actions)

CI/CD automates building, testing, and deploying code changes.

Key platforms:

  • GitHub Actions: event-driven YAML workflows, 15K+ marketplace actions, 2,000 free minutes/month
  • GitLab CI: stage-based pipelines, built-in DevSecOps, integrated security scanning
  • CircleCI, Travis CI, Jenkins: alternatives for various hosting setups

Common pipeline stages:

  1. Lint / format check
  2. Build / compile
  3. Run tests (unit + integration)
  4. Security/dependency scan
  5. Build and push container image
  6. Deploy to staging / production

Best practices:

  • Pin action versions for reproducibility
  • Run tests in isolation (test databases, mocked external services)
  • Use secrets management for API keys and credentials
  • Implement deployment environments and rollback

Resources:

Sources

This page synthesizes information from the following sources:

Clone this wiki locally