Library

Browse every StudyAtlas track — OS, networks, databases, JavaScript, Node, Express, MongoDB, Docker, AWS, Git and AI.

Operating Systems

Core operating system concepts for interviews and backend engineering.

• What is an Operating System? — What an OS is, why it exists, and what happens without it.
• Process Management — How the OS creates, runs, switches, and schedules executing programs.
• Process vs Thread — Core difference, context switching cost, when to prefer one over the other.
• Process States & Lifecycle — New, Ready, Running, Waiting, Terminated.
• CPU Scheduling Algorithms — FCFS, SJF, Round Robin, Priority Scheduling, Multilevel Queue.
• Multithreading vs Multiprocessing vs Multitasking — Clear distinction with real-world examples.
• Concurrency — Race Conditions, Critical Section, Mutex vs Semaphore.
• Deadlock — 4 Conditions, Prevention, Avoidance, Detection.
• Memory Management — Paging, Segmentation, Virtual Memory, Page Faults.
• Cache Memory & Locality of Reference — Temporal vs spatial locality and why caching improves performance.
• System Calls — fork, exec, and how user mode transitions to kernel mode.

Computer Networks

Networking concepts every backend developer should be able to explain.

• What is Computer Networking? — What networking is, why it exists, and real examples from everyday apps.
• OSI Model — The 7 OSI layers and what each layer is responsible for.
• TCP/IP Model — The practical 4-layer networking model used by the Internet.
• OSI vs TCP/IP & Encapsulation — How OSI maps to TCP/IP and how encapsulation moves data through layers.
• IP Addressing — What an IP address is and how it identifies devices on a network.
• Network ID & Host ID — How an IP address is split into network and device parts.
• Subnet Mask — How devices know which part of an IP address is the network part.
• CIDR — The slash notation used to describe network size, such as /24.
• Public vs Private IP — Why local devices use private IPs and servers use public IPs.
• Router & Default Gateway — How traffic leaves your local network.
• NAT — How many private devices share one public IP address.
• DHCP — How devices automatically receive IP configuration.
• ARP — How local networks resolve IP addresses to hardware addresses.
• Transport Layer — How applications choose reliable or fast delivery using TCP and UDP.
• TCP — Handshake, termination, sequence numbers, acknowledgements, retransmission, flow control, and congestion control.
• UDP — Difference from TCP, when to use UDP, and real-world examples.
• TCP vs UDP — Reliability, speed, ordering, error recovery, and use cases.
• DNS — DNS lookup process, caching, recursive resolvers, and why DNS is needed.
• Web Communication — How web clients and servers exchange requests, responses, and real-time messages.
• HTTP — Request/response, headers, methods, status codes, cookies, sessions, and keep-alive.
• HTTPS — SSL/TLS, certificates, encryption, and HTTPS request flow.
• REST API — REST principles, statelessness, resources, idempotency, and HTTP methods.
• WebSockets — Why HTTP is not enough, full-duplex communication, handshakes, and real-time apps.
• CORS — Same Origin Policy, preflight requests, and Access-Control-Allow-Origin.
• Cookies vs Sessions vs JWT — Authentication state mechanisms and when each one fits.
• Authentication vs Authorization — Identity verification versus permission checks.
• Network Infrastructure — Traffic distribution, proxying, edge delivery, ports, and socket-level programming.
• Load Balancer — Why load balancers are needed, round robin, least connections, and health checks.
• Reverse Proxy — Nginx and why backend servers use reverse proxies.
• CDN — Why images load faster, edge servers, and caching.
• Ports — How network services share one machine through numbered ports.
• Socket Programming — The programming interface behind network communication.

Object-Oriented Programming

OOP concepts, relationships, design principles, and common interview questions.

• Introduction to OOP — Why OOP emerged, where it is useful today, and how it relates to functional programming.
• Class & Object — The foundation of object-oriented modeling.
• Constructors — Why constructors exist, how they protect valid objects, and how this() and super() work.
• this & super — Common use cases for this and super.
• Static Keyword — Static variables, methods, blocks, and static vs instance members.
• Access Modifiers — Public, private, protected, and package-private access.
• Object Lifecycle & Memory — Object creation, references, heap, stack, and garbage collection.
• OOP Principles — The core ideas that make object-oriented design useful.
• Encapsulation — Data hiding, getters and setters, and benefits.
• Abstraction — Abstract classes, interfaces, examples, and abstraction vs encapsulation.
• Polymorphism — Method overloading, method overriding, and dynamic dispatch.
• Inheritance — Types of inheritance, extends, and method overriding.
• Relationships Between Classes — Association, aggregation, and composition.
• Composition vs Inheritance — Pros, cons, when to use each, and backend examples.
• Interface vs Abstract Class — Differences, use cases, and backend examples.
• Method Overloading vs Overriding — Differences, rules, and interview questions.
• Design Principles & Patterns — SOLID principles and common design patterns used to structure object-oriented code.
• SOLID Principles — Five object-oriented design principles that make code easier to change.
• Single Responsibility Principle — A class should have one clear reason to change.
• Open/Closed Principle — Code should be open for extension but closed for modification.
• Liskov Substitution Principle — Subtypes should be safely usable wherever the parent type is expected.
• Interface Segregation Principle — Prefer small focused interfaces over large forced contracts.
• Dependency Inversion Principle — High-level code should depend on abstractions, not concrete low-level classes.
• Design Patterns — Singleton, Factory, Adapter, Decorator, Strategy, and Observer.
• Common OOP Interview Questions — Frequently asked OOP interview questions.

Databases & SQL

Database fundamentals, SQL, transactions, scaling, and interview-heavy DBMS topics.

• Database Fundamentals — DBMS, RDBMS vs NoSQL, tables, rows, columns, schemas, and constraints.
• Database Design — Relationships, ER diagrams, junction tables, schema design, and cardinality.
• Keys & Constraints — Primary keys, foreign keys, candidate keys, composite keys, super keys, alternate keys, and unique keys.
• Normalization — Data redundancy, anomalies, 1NF, 2NF, 3NF, BCNF, and denormalization.
• SQL Basics — SELECT, WHERE, ORDER BY, DISTINCT, LIMIT, LIKE, IN, BETWEEN, IS NULL, and CASE.
• SQL Filtering & Sorting — Logical operators, aliases, and expressions.
• SQL Joins — INNER, LEFT, RIGHT, FULL, CROSS, and SELF JOIN.
• Aggregation — COUNT, SUM, AVG, MIN, MAX, GROUP BY, and HAVING.
• Intermediate SQL — Subqueries, correlated subqueries, EXISTS, ANY, ALL, UNION, INTERSECT, and EXCEPT.
• Window Functions — ROW_NUMBER(), RANK(), DENSE_RANK(), LEAD(), and LAG().
• Transactions — Transaction lifecycle and ACID properties.
• Concurrency Control — Dirty reads, non-repeatable reads, and phantom reads.
• Isolation Levels — Read uncommitted, read committed, repeatable read, and serializable.
• Locking — Shared locks, exclusive locks, row locks, table locks, optimistic locking, and pessimistic locking.
• Deadlocks — Causes, detection, prevention, and resolution.
• Database Programmability — Views, materialized views, stored procedures, functions, and triggers.
• Views — Views and materialized views.
• Stored Procedures & Triggers — Stored procedures, functions, and triggers.
• Database Performance & Scaling — Indexes, query optimization, scaling strategies, and advanced database internals.
• Indexing — B-Tree, hash indexes, clustered indexes, composite indexes, and table scans.
• Query Optimization — EXPLAIN, execution plans, optimizers, predicate pushdown, N+1, pagination, and SELECT *.
• Database Scaling — Vertical scaling, horizontal scaling, read replicas, partitioning, and sharding.
• Advanced Concepts — MVCC, WAL, replication, CAP theorem, BASE, connection pooling, and Redis caching.
• NoSQL — Non-relational database models and when they fit better than SQL.
• Types of NoSQL Databases — Document, key-value, wide-column, and graph database models.
• MongoDB & Document Databases — How document databases store JSON-like data and when MongoDB fits.
• Key-Value Databases — Fast key-based lookup using databases such as Redis.
• Wide-Column Databases — Distributed write-heavy storage using databases such as Cassandra.
• Graph Databases — Relationship-heavy data using nodes and edges.
• When to Use SQL vs NoSQL — Clear decision rules with practical examples.

AI for Backend Developers

AI fundamentals, APIs, RAG, pipelines, safety, and agent concepts for backend work.

• What is AI? — Artificial intelligence as pattern learning and problem solving.
• Machine Learning vs Deep Learning vs Generative AI — How common AI terms relate to each other.
• How ChatGPT works — A high-level explanation of language model behavior.
• Tokens — The units AI models read, write, and charge for.
• Context Window — How much information a model can consider at once.
• Temperature — How randomness affects model output.
• Hallucinations — Why models can produce plausible but wrong answers.
• Prompt Engineering — Writing instructions that produce useful model behavior.
• Prompt Templates — Reusable prompts for backend workflows.
• Chat Completion — Sending messages to a model and reading responses.
• Structured Output — Getting predictable JSON-shaped model responses.
• Function Calling / Tool Use — Letting models request typed actions from your backend.
• Streaming Responses — Sending partial model output to users as it arrives.
• Token Usage & Cost Calculation — Estimating AI feature cost from token usage.
• RAG — Retrieval augmented generation.
• Embeddings — Representing meaning as vectors.
• Vector Databases — Storing and searching vectors for semantic retrieval.
• Chunking for RAG — Splitting documents for better retrieval.
• Semantic Search vs Keyword Search — Meaning-based search compared with exact matching.
• AI Pipelines — Backend workflows that prepare, call, and post-process AI output.
• API Keys & Authentication — Authenticating safely with AI APIs.
• Caching for LLM responses — Caching model responses where it is correct and useful.
• Rate Limiting — Protecting AI endpoints from overuse.
• AI Security — Prompt injection, data leakage, and defensive backend design.
• What is an AI Agent? — The basic agent loop and how it differs from one-shot prompting.
• Agent Planning & Reasoning — How agents break work into steps.
• Agent Memory — Short-term and long-term memory in agent systems.
• Conversation Memory — Remembering useful context across turns.
• Tools / Function Calling in Agents — How agents use tools to affect external systems.
• Multi-Agent Systems — Multiple agents coordinating on a task.
• Agentic Workflows — Workflow patterns that combine model decisions and deterministic code.

AWS Fundamentals

Must-know AWS services and cloud concepts for backend developers.

• Cloud Basics and AWS Global Infrastructure — Cloud computing, Regions, Availability Zones and choosing a Region.
• VPC and Networking Basics — VPCs, public/private subnets, routing, gateways and security groups.
• IAM: Users, Roles and Policies — Authentication, permissions and least-privilege access.
• CloudWatch, Billing and Shared Responsibility — Logs, metrics, alarms, cost controls and AWS versus customer duties.
• S3: Object Storage — Buckets, objects, access control, versioning and common use cases.
• RDS: Managed Databases — Managed SQL databases, backups, Multi-AZ and connection safety.
• EC2: Virtual Servers — Instances, AMIs, instance types, key pairs and security groups.
• Load Balancing and Auto Scaling — Distributing traffic, health checks and automatically changing capacity.

React / Namaste React

React notes from the public NamasteReact course repository, covering foundations, routing, hooks, data flow, styling, optimization, and testing basics.

• React Roadmap — How to study React for frontend, MERN apps, and interviews.
• React Must Know — The core React concepts every MERN developer should understand first.
• React Inception — Set up React from first principles with plain HTML, DOM APIs, CDN scripts, React elements, and roots.
• Igniting a React App — Bundlers, package managers, Parcel, npm scripts, dependencies, browserslist, and production builds.
• Laying the Foundation — Babel, JSX, React elements, components, composition, and the early structure of a React app.
• Talk Is Cheap, Show Me the Code — Planning and building a food ordering app with components, props, config-driven UI, and project structure.
• Let’s Get Hooked — ES modules, React hooks, useState, state-driven rendering, reconciliation, and React Fiber basics.
• Exploring the World — Fetching data, service architectures, useEffect, shimmer UI, conditional rendering, and search filtering.
• Finding the Path — Client-side routing with react-router-dom, nested routes, outlets, dynamic routes, and error pages.
• Data Is the New Oil — Data layer thinking, context, prop drilling, lifting state, controlled components, and React data flow.
• React Good to Know — Useful React concepts after the core path is clear.
• Let’s Get Classy — Class components, props, state, lifecycle methods, async effects, and cleanup.
• Optimizing a React App — Custom hooks, modularity, single responsibility, lazy loading, Suspense, and code splitting.
• Styling React with Tailwind — CSS approaches in React, CSS frameworks, Tailwind setup, utility classes, and pros and cons.
• React Coding Exercises — Practice tasks commonly asked in React interviews and machine-coding rounds.
• Component Composition Exercise — Break a UI into reusable components with props and lists.
• Hooks and Data Fetching Exercise — Build loading, error, empty, and success states around API data.
• Routing and State Exercise — Build nested routes, detail pages, and shared app state.

JavaScript

JavaScript fundamentals, async behavior, browser/runtime concepts, and coding-round exercises.

• JavaScript Roadmap — How to study JavaScript for React, Node.js, interviews, and coding rounds.
• JavaScript Must Know — The core concepts every MERN developer should understand first.
• What is JavaScript? — What JavaScript is, why it exists, and where it runs.
• Execution Context and Call Stack — How JavaScript runs code step by step.
• Scope, Hoisting, var, let and const — How variable visibility and declaration behavior work.
• Closures — How functions remember variables from their outer scope.
• this Keyword — How this is decided in different call sites.
• Prototypes and Prototype Chain — How JavaScript objects inherit behavior.
• Arrays, Objects and Common Methods — Working with data using map, filter, reduce, spread, rest, and destructuring.
• Event Loop — Why asynchronous callbacks run after the current call stack.
• Promises and async await — How JavaScript represents and handles future async results.
• Error Handling — try/catch, throwing errors, and handling async failures.
• JavaScript Modules — CommonJS vs ES Modules and how imports/exports organize code.
• Debounce and Throttle — Control how often a function runs during frequent events.
• JavaScript Good to Know — Useful concepts that deepen understanding after the core path.
• Classes in JavaScript — Class syntax over prototype-based behavior.
• Shallow Copy vs Deep Copy — How object copying works and where reference bugs come from.
• Memory Leaks in JavaScript — Common ways references stay alive longer than expected.
• Currying and Memoization — Function patterns often asked in interviews and coding rounds.
• JavaScript Coding Exercises — Practice problems commonly asked in frontend and MERN coding rounds.
• Polyfills: map, filter and reduce — Implement common array methods from scratch.
• Implement Debounce and Throttle — Write reusable debounce and throttle helpers.
• Flatten Array and Deep Clone — Handle nested arrays and object copying safely.
• Promise Utilities — Implement Promise.all, sequential execution, retry, and timeout helpers.
• Event Emitter and LRU Cache — Build two common machine-coding round utilities.

Docker

Docker fundamentals for running and shipping backend applications.

• What is Docker? — A simple explanation of Docker, the problem it solves, and when you actually need it.
• Images, Containers and Registries — The relationship between an image, running container and registry.
• Writing a Dockerfile — FROM, WORKDIR, COPY, RUN, EXPOSE and CMD.
• Build and Run Commands — Building, starting, viewing, stopping and debugging containers.
• Volumes and Persistent Data — Why container files disappear and how volumes preserve data.
• Docker Networking — Container communication, service names and published ports.
• Docker Compose — Running a multi-container application with one YAML file.
• Configuration, Security and Optimization — Handle settings and secrets safely, then make your production image smaller and safer.

Node.js

Node.js runtime fundamentals, async IO, modules, streams, and backend coding exercises.

• Node.js Roadmap — How to study Node.js for backend development and interviews.
• Node.js Must Know — Core runtime concepts every backend developer should understand first.
• What is Node.js? — What Node.js is, why it exists, and when to use it.
• Node.js vs Browser JavaScript — Same language, different runtime capabilities and APIs.
• Node.js Event Loop and Non-blocking IO — libuv, event loop phases, microtasks, macrotasks, and callback priority in Node.js.
• Modules and NPM — CommonJS, ES Modules, npm packages, and project dependencies.
• File System and Path — Read, write, and resolve files safely in Node.js.
• Events and EventEmitter — Build event-driven code using Node.js EventEmitter.
• Streams and Buffers — Process large data without loading everything into memory.
• HTTP Server in Node.js — Create a basic server without Express to understand the foundation.
• Environment Variables and process — Use process.env, argv, exit codes, and runtime metadata.
• Node.js Error Handling — Handle sync errors, async errors, callbacks, and rejected promises.
• Node.js Good to Know — Useful runtime features after the core path.
• Worker Threads — Run CPU-heavy JavaScript work off the main thread.
• Child Processes — Run external commands or separate programs from Node.js.
• Package Versioning — Understand semver, package-lock, dependencies, and devDependencies.
• Node.js Security Basics — Protect secrets, dependencies, inputs, and runtime configuration.
• Node.js Coding Exercises — Backend coding exercises commonly asked around Node.js fundamentals.
• HTTP Server without Express — Build a tiny router with Node.js http module.
• Build a CLI Tool — Read command line arguments and create a useful script.
• File Upload with Streams — Use streams to handle large files efficiently.
• Custom EventEmitter — Implement a small event emitter from scratch.
• In-memory Rate Limiter — Limit repeated requests using Map and time windows.

Express.js

Express routing, middleware, REST APIs, auth, validation, and backend API exercises.

• Express.js Roadmap — How to study Express for real backend API development.
• Express.js Must Know — Core Express concepts for building maintainable APIs.
• What is Express? — What Express adds on top of Node.js and why it exists.
• Routing — Map HTTP methods and URLs to handler functions.
• Params, Query and Body — Understand where request input comes from.
• Middleware — How Express runs request logic in a chain.
• Controllers and Services — Separate HTTP handling from business logic.
• REST API Design — Design resource-based APIs using HTTP methods and status codes.
• Request Validation — Validate input before it reaches business logic.
• Error Handling Middleware — Centralize errors and responses in Express.
• Authentication and JWT — Verify user identity with tokens.
• Authorization — Control what authenticated users are allowed to do.
• CORS in Express — Allow controlled browser access from other origins.
• Pagination, Filtering and Sorting — Return large datasets in a controlled API shape.
• Express.js Good to Know — Useful production concepts after basic APIs work.
• Cookie Sessions — Store auth state with cookies and server/session strategy.
• File Uploads in Express — Accept files safely using middleware and storage rules.
• Rate Limiting in Express — Protect APIs from repeated abusive requests.
• Security Headers — Use headers to reduce common web risks.
• Testing Express APIs — Test routes, middleware, and error responses.
• Express.js Coding Exercises — Practice APIs commonly asked in backend coding rounds.
• CRUD API — Build create, read, update, and delete routes.
• JWT Auth API — Build login, register, and protected routes.
• Role-based Authorization API — Restrict routes by user role.
• Pagination and Search API — Add query-based list controls to an endpoint.
• URL Shortener API — Build a common backend machine-coding project.

MongoDB

MongoDB documents, schema design, indexes, aggregation, Mongoose, and database exercises.

• MongoDB Roadmap — How to study MongoDB for MERN apps and backend interviews.
• MongoDB Must Know — Core MongoDB concepts for practical backend development.
• What is MongoDB? — What MongoDB is, why document databases exist, and where it fits.
• Documents and Collections — How MongoDB stores JSON-like records.
• MongoDB vs SQL — How document databases differ from relational databases.
• CRUD Operations in MongoDB — Create, read, update, and delete documents.
• Query and Update Operators — Use operators like $set, $inc, $in, $gt, and $or.
• Schema Design in MongoDB — Design documents around access patterns.
• Embedding vs Referencing — Choose nested documents or separate linked collections.
• Indexes in MongoDB — Speed up queries with indexes and understand write tradeoffs.
• Aggregation Pipeline — Transform and summarize data with pipeline stages.
• Mongoose Schema and Model — Define application-level models for MongoDB documents.
• Mongoose Validation — Validate document shape and values before saving.
• Population in Mongoose — Replace referenced ids with related documents.
• MongoDB Good to Know — Useful concepts for stronger production data design.
• Transactions in MongoDB — Make multiple writes succeed or fail together.
• Compound and Text Indexes — Use multi-field and text search indexes.
• MongoDB Performance Mistakes — Avoid unindexed queries, huge documents, and bad pagination.
• MongoDB Data Modeling Patterns — Use common document modeling patterns for real apps.
• MongoDB Coding Exercises — Practice schema design, CRUD, search, aggregation, and transactions.
• User Post Comment Schema — Design social-style collections and relationships.
• CRUD with Mongoose — Build model-based create, read, update, and delete operations.
• Search and Pagination in MongoDB — Implement query search and paginated lists.
• Aggregation Reports — Calculate grouped summaries using aggregation pipeline.
• Order Placement with Transaction — Use transactions for multi-document order flow.

MERN Integration

How React, Node, Express, and MongoDB connect in real full-stack applications.

• MERN Integration Roadmap — How the four MERN parts connect into one application.
• MERN Must Know — The full-stack concepts needed before building projects.
• MERN Architecture — How React, Express, Node, and MongoDB communicate.
• Frontend vs Backend Responsibility — Decide what belongs in React and what belongs on the server.
• API Contract — Define request and response shapes between frontend and backend.
• Authentication Flow in MERN — Connect login, tokens/cookies, protected APIs, and UI state.
• Protected Routes — Protect frontend screens and backend endpoints correctly.
• Full-stack Error Handling — Handle errors consistently from database to UI.
• CORS in MERN — Understand why local React and Express apps hit CORS errors.
• Environment Variables in MERN — Separate frontend and backend configuration safely.
• Deployment Overview — Build React, run the API, connect env vars, and deploy safely.
• MERN Projects — Full-stack projects that combine React, Express, Node.js, and MongoDB.
• Todo App with Auth — Build auth, CRUD, protected routes, and user-owned data.
• Blog App with Comments — Build posts, comments, authors, and moderation basics.
• Notes App with Search — Build notes, search, pagination, and ownership.
• URL Shortener — Build slug generation, redirects, analytics, and validation.
• Basic E-commerce App — Build products, cart, orders, and transaction thinking.

Git & GitHub

Git fundamentals, branching, collaboration, and GitHub workflows from scratch.

• What is Git? — Why version control exists, what Git solves, and what happens without it.
• Repository, Working Tree, Staging Area and Commit — The core Git mental model: where changes live before they become history.
• Installing and Configuring Git — Set name, email, editor, default branch, and authentication basics.
• Daily Git Workflow — The commands used in normal development: status, add, commit, log, diff, and restore.
• git status, diff, add and commit — See changes, choose what to save, and create meaningful commits.
• Reading Git History — Use log, show, blame, and diff to understand how code changed.
• Undoing Changes Safely — Restore files, amend commits, revert bad commits, and know when reset is risky.
• Ignoring Files with .gitignore — Keep dependencies, secrets, builds, and local files out of Git.
• Branches and Merging — Work on isolated lines of development and combine changes safely.
• Merge vs Rebase — Two ways to integrate branch work and when each one makes sense.
• Merge Conflicts — Why conflicts happen and how to resolve them without panic.
• Stash and Temporary Work — Put unfinished work aside when you need to switch context.
• Remote Repositories — How local Git history connects to shared repositories through clone, fetch, pull, and push.
• Clone, Fetch, Pull and Push — Understand the commands that move commits between your machine and a remote.
• GitHub Basics — What GitHub adds on top of Git: hosting, issues, pull requests, reviews, and collaboration.
• Pull Requests and Code Review — Use PRs to discuss, review, test, and merge code as a team.
• Forks, Upstream and Open Source Workflow — Contribute to repositories you do not own using forks and upstream remotes.

GitHub CI/CD

GitHub Actions workflows for CI, image publishing, and deployment.

• What is GitHub CI/CD? — A beginner-friendly explanation of CI, CD, why teams use it, and a real example.
• GitHub Actions: How It Works — The GitHub feature that runs your automation: workflows, jobs, steps, actions, and runners.
• When Should a Workflow Run? — Choose pull requests, pushes, manual runs, and path filters for the task.
• Your First CI Pipeline — Set up a simple check that installs, lints, tests, and builds your app.
• Artifacts, Docker Images and Registries — Passing build output forward and publishing versioned images.
• Secrets, Tokens and Permissions — Safely authenticating deployments and limiting workflow access.
• Deploying Safely — Use staging, production approvals, and a rollback plan when you start releasing automatically.