Core CS Subjects for Interviews: What to Study, in What Order, and How Deep

What "core CS" means in interviews

Core computer science subjects are the fundamentals taught in a degree: data structures and algorithms, object-oriented programming, database management systems (DBMS), operating systems (OS) and computer networks, with some companies adding computer architecture and software engineering basics. They are tested in written placement tests, technical interviews and sometimes in "fundamentals" rounds. Even if your job never uses them directly, interviewers use them to judge whether you understand how things work under the surface.

1. Priority by company type

Company type	Heaviest focus	Then
Service companies (mass hiring)	Aptitude, basic programming, DBMS and SQL, OOP, OS basics	Networks, projects, communication
Product companies	DSA, problem solving	OOP and low-level design, OS, DBMS, system design basics
Startups	Practical coding, your projects, one language in depth	DBMS and APIs, basics of OS and networks
Embedded and hardware-linked	C, OS, microcontrollers, computer architecture	Networks, protocols (embedded roadmap)
Data roles	SQL, statistics, Python	DBMS, DSA basics (data analyst, data engineer)

Check the specific company's process (interview process explained) and weight your time accordingly.

2. Programming language fluency (the base for everything)

Choose one language and know it well enough to write code without an IDE: Python, Java or C++. Be able to explain how its memory, strings, collections and error handling work.

3. Data structures and algorithms

Arrays, strings, linked lists, stacks, queues, hash tables, trees, heaps, graphs, sorting, searching, recursion, dynamic programming and complexity analysis. Know how each structure works internally and when to use it. See the DSA guide and dynamic programming explained.

4. Object-oriented programming

Classes and objects, the four pillars (encapsulation, abstraction, inheritance, polymorphism), overloading vs overriding, abstract classes vs interfaces, composition vs inheritance, SOLID, common design patterns and small low-level design problems. See the OOP guide.

5. Database management systems

Keys, ER diagrams, normalisation (1NF to BCNF), transactions and ACID, isolation levels, indexing, joins and SQL queries, SQL vs NoSQL. SQL is also tested practically. See the DBMS guide and SQL practice.

6. Operating systems

Processes and threads, scheduling, synchronisation, deadlocks, memory management, virtual memory and page replacement, file systems, and Linux basics. See the OS guide and Linux essentials.

7. Computer networks

OSI and TCP/IP layers, IP addressing and subnetting, TCP vs UDP, DNS, HTTP and HTTPS, security basics, and "what happens when you type a URL". See the networks guide.

8. Supporting topics

• System design basics (scaling, caching, load balancing, databases): for experienced roles and strong product-company candidates (guide)
• Git and version control: commits, branches, merging, resolving conflicts (Git guide)
• Software engineering: SDLC, Agile and Scrum, testing types, code review
• Computer architecture (embedded and some service tests): number systems, CPU, memory hierarchy, cache, pipelining
• Web basics: how APIs work, REST, JSON, authentication, and front-end fundamentals (frontend, backend)
• Cloud and DevOps basics: containers, CI/CD (Docker and Kubernetes)
• Aptitude and English: quantitative, logical and verbal sections in many campus tests

9. Software engineering basics worth a few lines

• SDLC models: waterfall (sequential), iterative, spiral and Agile
• Scrum: sprints, roles (product owner, scrum master, team), ceremonies (planning, daily stand-up, review, retrospective)
• Testing: unit, integration, system and acceptance tests; black-box vs white-box; regression testing (QA roadmap)
• CI/CD: automatically building, testing and deploying every change

10. A suggested order of study

1. Weeks 1-2: one language plus complexity analysis
2. Weeks 3-6: DSA (arrays to graphs) alongside daily coding
3. Week 7: OOP
4. Week 8: DBMS and SQL
5. Week 9: OS
6. Week 10: networks
7. Week 11: projects review, Git, system design basics
8. Week 12: mock interviews, aptitude and HR preparation (HR guide)

If time is short, cover the most-asked 20% of each subject first: for OS, processes vs threads, scheduling, deadlock and paging; for DBMS, keys, normalisation, ACID and indexes; for networks, TCP vs UDP, DNS, HTTP and the URL journey; for OOP, the four pillars, SOLID and patterns.

11. How deep to go

• Fresher at a service company: definitions, differences, one example for each, and the ability to write basic programs and queries
• Fresher at a product company: the same plus internals (how a hash map works, how a process is scheduled) and the ability to reason about trade-offs
• Experienced: how you used these ideas in real systems: debugging a deadlock, tuning a slow query, designing for scale

12. How to turn knowledge into good answers

• Use the pattern definition, example, trade-off
• Compare related ideas: stack vs heap, process vs thread, TCP vs UDP, clustered vs non-clustered index
• Link subjects together: "A database deadlock is the same four conditions we see in operating systems"
• Be honest about gaps: "I have not used that in production, but I understand it as..."
• Practise answering aloud and time yourself (about two minutes per concept)

13. Common mistakes

• Memorising definitions without examples
• Spending months on DSA and ignoring DBMS, OS and networks, which are easy marks in many tests
• Studying passively; solve numericals, write queries and code
• Skipping revision, so earlier topics fade
• Not connecting projects to concepts; be ready to explain the database design, concurrency and API choices in your own project (projects guide)

Finish with the technical interview checklist and online assessment tips.