Roadmaps › CS Fundamentals
CS Fundamentals Roadmap
OOP, Operating Systems, DBMS, Computer Networks and System Design — the core subjects asked in interviews and GATE.
Level: Beginner → Intermediate · Duration: 2–3 months
Step 1: Object-Oriented Programming
How to model programs with objects.
OOP organises programs around objects that combine data and behaviour. It is asked in almost every placement interview, so learn each concept with a definition, a real-life example and a short code example.
- Classes, objects and constructors
- The four pillars
- Abstract classes and interfaces
- Design principles (SOLID)
Resources: Interview questions: OOP
Classes, objects & constructors
And access modifiers.
A class is a blueprint; an object is a real instance made from it. Constructors initialise objects, and access modifiers decide what outside code can touch.
- Class vs object with examples
- Default, parameterised and copy constructors
- Access modifiers: public, private, protected
- static members
Resources: Notes: Classes, Objects, Constructors
Encapsulation, abstraction, inheritance, polymorphism
With examples.
These four ideas are the heart of OOP. Interviewers often ask you to explain each with a real example and how it appears in code.
- Encapsulation: data hiding with getters/setters
- Abstraction: showing only what is needed
- Inheritance: reuse with "is-a" relationships
- Polymorphism: overloading (compile time) vs overriding (runtime)
Resources: Notes: Four Pillars of OOP
Abstract class vs interface
Differences and when to use each.
Both describe behaviour without fully implementing it, but they differ in state, constructors, method types and multiple inheritance — a very common interview question.
- Key differences in a comparison table
- Multiple inheritance via interfaces
- When to use which
Resources: Notes: Abstract Class vs Interface
SOLID principles
Good class design.
SOLID is five principles for writing classes that are easy to extend and maintain — useful in low-level design rounds.
- Single responsibility and open/closed
- Liskov substitution
- Interface segregation
- Dependency inversion
Resources: Notes: SOLID Principles
Step 2: Operating Systems
How the OS shares the CPU, memory and devices.
An operating system manages the CPU, memory, storage and devices so programs can share them safely. OS questions test whether you understand what happens beneath your code.
- Processes and threads
- CPU scheduling
- Synchronization and deadlocks
- Memory management
Resources: ▶ Operating System · Interview questions: Operating Systems
Processes & threads
PCB, states, context switch.
A process is a running program with its own address space; threads run inside a process and share its memory. The OS switches between them constantly.
- Process states and the PCB
- Process vs thread
- Context switching
- User vs kernel threads
Resources: Notes: Process vs Thread
CPU scheduling
FCFS, SJF, priority, round robin.
Scheduling algorithms decide which ready process gets the CPU next, balancing waiting time, response time and fairness.
- FCFS, SJF, SRTF, priority, round robin
- Preemptive vs non-preemptive scheduling
- Computing waiting and turnaround time
- Starvation and aging
Resources: Notes: CPU Scheduling Algorithms
Synchronization
Critical section, mutex, semaphore.
When processes or threads share data, they must coordinate or the data gets corrupted. The critical-section problem and its solutions are core OS topics.
- Race conditions and critical sections
- Mutex locks and semaphores
- Producer–consumer and readers–writers problems
- Monitors
Deadlocks
Coffman conditions and handling.
A deadlock is a set of processes each waiting for a resource held by another. Know when it can happen and the strategies to handle it.
- The four necessary conditions
- Resource allocation graphs
- Prevention, avoidance (Banker's algorithm), detection and recovery
Resources: Notes: Deadlocks
Memory management
Paging, segmentation, page replacement.
The OS maps each process's logical addresses to physical memory and uses virtual memory to run programs larger than RAM.
- Contiguous allocation and fragmentation
- Paging, page tables and TLB
- Segmentation
- Virtual memory, page faults and page replacement (FIFO, LRU, Optimal)
Resources: Notes: Memory Management
File systems & disk scheduling (optional)
For GATE and OS-heavy roles.
File systems organise data on disk; disk scheduling orders read/write requests to reduce seek time. Mostly important for GATE.
- File allocation methods
- Directory structures
- FCFS, SSTF, SCAN, C-SCAN disk scheduling
Step 3: Database Management Systems
Store data correctly and query it fast.
DBMS covers how data is modelled, stored, queried and kept consistent. Expect conceptual questions plus SQL queries in interviews.
- Data modelling with ER diagrams
- Normalization
- SQL
- Transactions and indexing
Resources: ▶ DBMS Complete Playlist · Interview questions: DBMS
ER model & keys
Entities, relationships, primary/foreign keys.
ER diagrams model entities, their attributes and relationships before tables are created. Keys uniquely identify rows and link tables.
- Entities, attributes and relationships
- Cardinality: one-to-one, one-to-many, many-to-many
- Super, candidate, primary and foreign keys
Resources: Notes: Keys and Normalization
Normalization
1NF, 2NF, 3NF, BCNF.
Normalization splits tables to remove redundancy and anomalies, guided by functional dependencies.
- Functional dependencies
- 1NF, 2NF, 3NF and BCNF
- Insert, update and delete anomalies
- When denormalization is useful
SQL
Queries, joins, subqueries, GROUP BY.
SQL is how you define and query relational data. Practise writing queries by hand — interviews often ask for them on paper.
- DDL vs DML
- Joins, GROUP BY and HAVING
- Subqueries and the Nth highest salary
- Views
Resources: SQL practice (live database) · Notes: SQL Essentials and Joins · SQL documentation
Transactions & concurrency
ACID, isolation levels, locks.
Transactions keep data correct even when many users change it at once. Concurrency control prevents problems like lost updates and dirty reads.
- ACID properties
- Schedules and serializability
- Isolation levels and read phenomena
- Two-phase locking
Resources: Notes: Transactions and ACID
Indexing
B/B+ trees, hashing.
Indexes are extra data structures that make searches fast. B and B+ trees are the standard for databases.
- Primary, clustered and secondary indexes
- B tree vs B+ tree
- Hash indexes
- Trade-offs of indexing
Resources: Notes: Indexing and B+ Trees
Step 4: Computer Networks
How data travels across the internet.
Computer networks explain how data travels between machines — from cables and IP addresses to HTTP. Networking basics are asked in most technical interviews.
- Layered network models
- Addressing and routing
- Transport protocols
- Application protocols
Resources: ▶ Computer Networks · Interview questions: Computer Networks
OSI & TCP/IP
Layers and their protocols.
Layered models split networking into simpler parts. Know each layer's job and an example protocol.
- Seven OSI layers
- Four TCP/IP layers and how they map
- Encapsulation of data through layers
- Devices per layer: hub, switch, router
Resources: Notes: OSI and TCP/IP Models
IP addressing & subnetting
CIDR, subnet masks.
IP addresses identify devices; subnetting divides networks into smaller ones. Subnet calculations are common in GATE and networking roles.
- IPv4 classes and CIDR notation
- Subnet masks and calculating hosts
- Private vs public IPs and NAT
- IPv6 basics
Resources: Notes: IP Addressing and Subnetting
TCP & UDP
Handshake, flow and congestion control.
TCP gives reliable, ordered delivery with flow and congestion control; UDP is lightweight and fast without guarantees.
- Three-way handshake and connection termination
- Flow control (sliding window)
- Congestion control basics
- When to use UDP
Resources: Notes: TCP vs UDP
Application layer
HTTP, DNS, DHCP, email protocols.
Application protocols are what users actually experience: web pages, domain names, email.
- HTTP/HTTPS and status codes
- DNS resolution
- DHCP
- SMTP, POP3 and IMAP
Resources: Notes: What Happens When You Type a URL
Step 5: System Design basics
How large systems handle millions of users.
System design is about building software that serves millions of users reliably. Learn the building blocks and practise a few classic designs.
- Scaling techniques
- Caching and CDNs
- Databases at scale
- High-level and low-level design practice
Resources: Interview questions: System Design · ▶ System Design Playlist
Scalability
Load balancers, horizontal scaling, stateless servers.
Scalable systems handle growth by adding machines rather than buying one giant server. Stateless services behind load balancers are the starting point.
- Vertical vs horizontal scaling
- Load balancers
- Stateless services
- CAP theorem in simple terms
Resources: Notes: Scalability
Caching, CDN & databases at scale
Replication, sharding.
Caches and CDNs serve repeated data quickly; replication and sharding let databases handle more load.
- Cache placement and eviction (LRU)
- CDNs for static content
- Replication and read replicas
- Sharding and partitioning
Resources: Notes: Caching, CDN and Databases
High-level design practice
URL shortener.
High-level design draws the big boxes: clients, services, databases, caches and how data flows between them.
- Requirements and capacity estimates
- Designing a URL shortener
- Discussing trade-offs clearly
Resources: Notes: Design a URL Shortener
Low-level design practice
Parking lot.
Low-level design is about classes, interfaces and relationships for one component — like a parking lot or library system.
- Identifying classes and responsibilities
- Using interfaces and design patterns
- Designing a parking lot
Resources: Notes: Low-Level Design: Parking Lot
Step 6: Theory for GATE (optional)
Extra subjects if you are preparing for GATE CSE.
GATE CSE covers a few theory-heavy subjects rarely asked in placements. Add them if you are preparing for GATE or higher studies.
- Theory of computation
- Compiler design
- Discrete mathematics
- Computer organisation
Resources: ▶ Theory of Computation · ▶ Computer Organization and Architecture
Theory of Computation
Automata, regular languages, Turing machines.
TOC studies what machines can compute: finite automata, grammars and Turing machines.
- DFA, NFA and regular expressions
- Context-free grammars and pushdown automata
- Turing machines and decidability
Compiler Design
Lexing, parsing, code generation.
Compiler design explains how source code becomes machine code through several phases.
- Lexical analysis and tokens
- Parsing: LL and LR
- Syntax-directed translation and code generation
Discrete maths
Sets, relations, graphs, combinatorics.
Discrete maths is the mathematical foundation of computer science and a large part of GATE.
- Sets, relations and functions
- Propositional and predicate logic
- Graph theory and combinatorics
Computer Organisation
Pipelining, cache, number systems.
Computer organisation explains how a CPU, memory and I/O actually work together.
- Number systems and instruction formats
- Pipelining and hazards
- Cache memory and mapping techniques