Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

Roadmaps › Web Development

Backend Developer Roadmap

Design APIs, model data, secure users and run servers — with Node.js (or Java / Python) and SQL + NoSQL databases.

Level: Intermediate · Duration: 4–6 months

Step 1: Internet & HTTP

How clients and servers talk.

A backend developer builds the server side of the web: the part that receives requests, runs business logic, talks to databases and sends responses. Everything starts with HTTP, the protocol your API speaks, so understand it deeply before choosing a framework.

  • Client–server architecture
  • The full request/response cycle
  • How browsers, mobile apps and other servers call your API
  • Statelessness and why it matters for scaling

Resources: Notes: What Happens When You Type a URL · Notes: TCP vs UDP

HTTP methods & status codes

GET/POST/PUT/DELETE, 2xx/4xx/5xx.

Methods say what the client wants to do and status codes say what happened. Using them correctly makes your API predictable for every frontend and mobile developer who uses it.

  • GET, POST, PUT, PATCH, DELETE and idempotency
  • 2xx success, 3xx redirects, 4xx client errors, 5xx server errors
  • 201 Created, 204 No Content, 400, 401 vs 403, 404, 409, 429, 500
  • Request and response bodies (JSON)

Headers, cookies & CORS

What the browser sends and allows.

Headers carry metadata like content type, auth tokens and caching rules. Cookies store small data in the browser. CORS is the browser rule that decides which websites may call your API — and the cause of many confusing errors.

  • Content-Type, Authorization, Cache-Control headers
  • Cookies: HttpOnly, Secure, SameSite
  • What CORS is and how to configure allowed origins
  • Preflight (OPTIONS) requests

DNS & HTTPS

Domains and TLS certificates.

DNS points your domain to your server; HTTPS encrypts traffic with TLS certificates. Every production API must run on HTTPS.

  • DNS records (A, CNAME) for an API domain
  • TLS certificates and Let's Encrypt
  • Why mixed content and plain HTTP are blocked

Step 2: A backend language

Pick one and go deep.

Pick one backend language and framework and go deep rather than learning three halfway. Node.js lets you use JavaScript everywhere; Java with Spring Boot dominates large companies; Python is quick to write and popular for data-heavy apps.

  • One language plus its main web framework
  • Package manager and project structure
  • Handling requests, routing and errors
  • Async I/O or threading model of your language

Resources: Node.js documentation · Java documentation · Python documentation

Node.js (JavaScript)

Event loop, async I/O, npm.

Node.js runs JavaScript on the server with a non-blocking event loop, which makes it great for APIs that do lots of I/O. Express is the simplest and most common framework on top of it.

  • The event loop and non-blocking I/O
  • npm, modules and environment variables
  • Express routes, middleware and error handling
  • async/await with database calls

Resources: ▶ Chai aur JavaScript Backend

Java + Spring Boot (optional)

Strong typing, huge in enterprises.

Spring Boot is the standard for enterprise Java backends: dependency injection, auto-configuration and a huge ecosystem for databases, security and messaging.

  • Controllers, services and repositories
  • Spring Data JPA
  • Spring Security
  • Building and running a JAR

Resources: ▶ Spring 6 & Spring Boot

Python + FastAPI / Django (optional)

Quick to write, great for data-heavy apps.

FastAPI builds fast, typed APIs with automatic docs; Django is a batteries-included framework with an ORM and admin panel.

  • FastAPI routes and Pydantic models
  • Django models, views and the admin
  • Virtual environments and requirements

Step 3: Linux & terminal

Servers run Linux.

Almost every server runs Linux. You will deploy, debug and read logs from a terminal, so basic command-line comfort is essential.

  • Navigating the file system
  • Permissions and users
  • Processes, ports and logs
  • Editing files on a server

Resources: Bash documentation · ▶ Linux for Beginners

Shell basics

Files, permissions, processes.

A small set of shell commands covers most daily server work: moving around, reading files, searching logs and checking what is running.

  • ls, cd, cp, mv, rm, mkdir, cat, less
  • grep, find and pipes
  • chmod and file permissions
  • ps, top, kill and checking open ports

SSH

Log into a remote server.

SSH lets you log in to a remote server securely. Key-based login is safer than passwords.

  • Connecting with ssh user@host
  • Generating and using SSH keys
  • Copying files with scp

Step 4: Relational databases

Tables, SQL and transactions.

Relational databases (PostgreSQL, MySQL) store data in tables linked by keys and guarantee correctness with transactions. Most business data — users, orders, payments — lives in one.

  • Tables, rows, keys and relationships
  • Writing SQL confidently
  • Normalization and schema design
  • Transactions and indexes

Resources: SQL documentation · PostgreSQL documentation · ▶ DBMS Complete Playlist · ▶ SQL Complete Course (MySQL)

SQL & joins

SELECT, JOIN, GROUP BY.

SQL is how you ask a relational database for data. Joins combine tables; aggregates summarise them.

  • SELECT, WHERE, ORDER BY, LIMIT
  • INNER and LEFT joins
  • GROUP BY, HAVING and aggregate functions
  • Subqueries and CTEs

Resources: SQL practice (live database) · Notes: SQL Essentials and Joins

Normalization & keys

Design tables that do not repeat data.

Good schema design avoids storing the same fact twice. Primary and foreign keys connect tables and protect data integrity.

  • Primary and foreign keys, constraints
  • 1NF to 3NF in practice
  • One-to-many and many-to-many relationships
  • When to denormalize for speed

Resources: Notes: Keys and Normalization

Transactions & ACID

Keep data correct under concurrency.

Transactions make several changes all-or-nothing — essential for anything involving money or stock. ACID describes the guarantees databases give.

  • BEGIN, COMMIT, ROLLBACK
  • Atomicity, consistency, isolation, durability
  • Isolation levels and race conditions
  • Optimistic vs pessimistic locking

Resources: Notes: Transactions and ACID

Indexes

Make queries fast.

An index lets the database find rows without scanning the whole table. The right index can turn a 2-second query into 2 milliseconds.

  • How B+ tree indexes work
  • Single vs composite indexes
  • Reading a query plan with EXPLAIN
  • The write cost of too many indexes

Resources: Notes: Indexing and B+ Trees

Step 5: NoSQL databases

Flexible documents and key-value stores.

NoSQL databases trade some relational features for flexibility or speed. Document stores like MongoDB hold JSON-like data; key-value stores like Redis are extremely fast for caching.

  • Document, key-value, column and graph databases
  • Schema flexibility and its risks
  • Choosing the right database for the job

Resources: MongoDB documentation · ▶ Complete MongoDB Tutorial

MongoDB

Documents, Mongoose, aggregation.

MongoDB stores JSON-like documents, so data can be read in the same shape your app uses. Mongoose adds schemas and validation in Node.js.

  • Documents, collections and _id
  • CRUD operations and queries
  • Embedding vs referencing
  • Indexes and the aggregation pipeline

Redis

Caching and sessions.

Redis keeps data in memory, so reads and writes take microseconds. It is used for caching, sessions, rate limiting and simple queues.

  • Strings, hashes, lists and sets
  • Expiring keys (TTL)
  • Caching database results
  • Rate limiting with counters

Resources: Redis documentation

When SQL vs NoSQL (optional)

Trade-offs.

Neither is better everywhere. Relational databases shine with structured, related data and transactions; NoSQL shines with flexible schemas and simple, high-volume access patterns.

  • Consistency and transactions
  • Schema flexibility
  • Scaling patterns of each

Resources: Notes: SQL vs NoSQL

Step 6: APIs

Expose your data to apps.

An API is the contract between your backend and its clients. Good APIs are consistent, documented, validated and return clear errors.

  • REST principles
  • Input validation and error responses
  • Pagination, filtering and sorting
  • API documentation (OpenAPI/Swagger)

REST design

Resources, status codes, pagination, versioning.

REST models your app as resources (users, orders) accessed with HTTP methods. Consistent naming and status codes make an API easy to use.

  • Resource-based URLs (/users/42/orders)
  • Using methods and status codes correctly
  • Pagination and filtering with query parameters
  • Versioning (/v1/)

Validation & errors

Never trust input; return clear messages.

Never trust input from the client. Validate everything at the API boundary and return helpful, consistent error messages without leaking internal details.

  • Validating body, params and query
  • A single error format across the API
  • Central error-handling middleware
  • Hiding stack traces in production

GraphQL (optional)

Clients ask for exactly the fields they need.

GraphQL lets clients ask for exactly the fields they need in one request, which helps apps with many screens and nested data.

  • Schemas, queries and mutations
  • Resolvers
  • The N+1 problem and DataLoader

Resources: GraphQL documentation

WebSockets (optional)

Real-time updates.

WebSockets keep a connection open so the server can push updates instantly — chat, live scores, notifications.

  • HTTP polling vs WebSockets
  • Socket.IO basics: rooms and events
  • Scaling real-time servers

Step 7: Authentication & security

Protect users and data.

Authentication checks who a user is; authorisation decides what they may do. Security mistakes here are the most costly, so learn the standard, proven approaches.

  • Password storage
  • Sessions vs tokens
  • Social login with OAuth
  • Common attacks and how to block them

Password hashing

bcrypt / argon2 — never store plain passwords.

Passwords must never be stored as plain text or with fast hashes like MD5. Use a slow, salted algorithm designed for passwords.

  • Why hashing (not encryption) and why salts
  • bcrypt or argon2
  • Password reset flows with expiring tokens

JWT & sessions

Stateless tokens vs server sessions.

Sessions store login state on the server and give the browser a cookie; JWTs are signed tokens the client sends with each request. Each has trade-offs around revocation and scaling.

  • Server sessions with cookies
  • JWT structure, signing and expiry
  • Access + refresh tokens
  • Role-based access control

OAuth (Google login)

Sign in with another provider.

OAuth lets users sign in with Google or GitHub instead of a new password. Your server verifies the provider's token and creates or finds the user.

  • The OAuth / OpenID Connect flow
  • Verifying Google ID tokens on the server
  • Linking social accounts to existing users

OWASP basics

Injection, XSS, CSRF, rate limiting.

The OWASP Top 10 lists the most common web vulnerabilities. Knowing them helps you avoid injection, broken auth and data leaks.

  • SQL/NoSQL injection and parameterised queries
  • XSS and CSRF
  • Rate limiting and brute-force protection
  • Keeping secrets out of code and logs

Step 8: Caching & performance

Serve more users with the same server.

As traffic grows, the same work gets repeated thousands of times. Caching stores results so they can be reused, and background jobs move slow work out of the request.

  • Where to cache: client, CDN, server, database
  • Cache invalidation strategies
  • Moving slow work to background jobs

Resources: Notes: Caching, CDN and Databases at Scale

Caching

Redis, HTTP caching headers.

A cache keeps frequently used data close and fast. The hard part is deciding when cached data is stale.

  • HTTP caching headers
  • Redis cache-aside pattern
  • TTLs and invalidation on update

Background jobs

Queues for slow work (emails, reports).

Sending emails, generating reports or resizing images should not make the user wait. Put them on a queue and process them with a worker.

  • Job queues (BullMQ, RabbitMQ, SQS)
  • Retries and failure handling
  • Scheduled (cron) jobs

Step 9: Testing

Change code without fear.

Tests let you change code with confidence and catch bugs before users do. Backends need both small unit tests and tests that call the real API.

  • Unit vs integration tests
  • Test databases and fixtures
  • Running tests in CI

Unit tests

Jest / JUnit / pytest.

Unit tests check one function or module in isolation, mocking slow or external dependencies.

  • Jest / JUnit / pytest basics
  • Arrange–act–assert
  • Mocking databases and external APIs

API tests

Supertest / Postman collections.

API tests send real HTTP requests to your app and check the responses, covering routing, validation and database together.

  • Supertest / REST Assured / httpx
  • Testing auth-protected routes
  • Seeding and cleaning a test database

Step 10: Deployment & DevOps basics

Get your API online and keep it healthy.

Code is only useful once it is running reliably for users. Learn to package your app, deploy it automatically and know when it breaks.

  • Containers
  • Automated pipelines
  • Cloud hosting options
  • Logs and monitoring

Resources: Docker documentation · ▶ DevOps Zero to Hero

Docker

Containerise your app.

Docker packages your app and its dependencies into an image that runs the same on your laptop and in production.

  • Writing a Dockerfile
  • Images, containers and volumes
  • docker compose for app + database

CI/CD

GitHub Actions: test and deploy on every push.

Continuous integration runs your tests on every push; continuous deployment ships passing code automatically.

  • GitHub Actions workflows
  • Running lint and tests in CI
  • Deploying on merge to main

Cloud hosting

Render, Railway, AWS basics.

Platforms like Render and Railway deploy from GitHub with little setup; AWS, GCP and Azure give full control and scale.

  • PaaS (Render, Railway) vs IaaS (AWS EC2)
  • Environment variables and secrets
  • Managed databases

Logging & monitoring (optional)

Know when something breaks.

Logs and metrics tell you what your app is doing in production and alert you before users complain.

  • Structured logging
  • Health checks and uptime monitoring
  • Error tracking and alerts

Step 11: System design basics (optional)

Design for many users.

System design is about building software that keeps working as users grow. Even for juniors, knowing the building blocks helps in interviews and real work.

  • Load balancers, caches, queues and databases
  • Horizontal vs vertical scaling
  • Trade-offs: consistency, availability, latency

Resources: Interview questions: System Design · ▶ System Design Playlist

Scalability

Vertical vs horizontal scaling, load balancers.

Scaling means handling more traffic: make servers stateless so you can add more behind a load balancer, cache hot data and scale the database with replicas.

  • Vertical vs horizontal scaling
  • Stateless services and load balancing
  • Read replicas and sharding basics

Resources: Notes: System Design Basics: Scalability

Design a URL shortener

A classic interview exercise.

A classic beginner design problem that covers ID generation, database choice, caching and redirects.

  • Generating short unique codes
  • Storage and lookup design
  • Caching popular links
  • Estimating traffic and storage

Resources: Notes: Design a URL Shortener