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