Scope before you build
Turn vague requirements into clear goals, estimate capacity, and define the API contracts a system must honour.
ARCHITECTURE & SCALABLE SYSTEMS
System Design.
Think. Design. Scale.
Turn requirements into scalable systems. Learn to choose the right building blocks for data, services and reliability, and explain the tradeoffs behind every decision.
- Requirements & estimation
- Scalable building blocks
- Design interviews
ENQUIRE ABOUT THE COURSE
Your next chapter
Your next chapter
starts here.
Tell us a little about yourself.
Complete your syllabus request in the open window.
YOUR STARTING POINTProgramming experience
YOUR ROADMAP28 learning modules
COURSE DURATIONBatch-specific
YOUR LEARNING MODEClassroom or live
A FOUNDATION THAT TAKES YOU FURTHER
Understand the problem.
Own the solution.
Build more than familiarity with syntax. Learn how to approach an unfamiliar problem, reason about your choices, and turn your thinking into working code.
Built a few apps? Time to design at scale.
For students and working professionals who can program and understand basic web applications, and want to design systems that scale.
Choose the right building blocks
Pick storage, caching, queues and load balancing that fit the workload. Understand what makes a system scale.
Defend your tradeoffs
Walk through your design, plan for failure, and explain the consistency, latency and cost decisions that matter.
YOUR LEARNING ROADMAP
One concept leads
to the next breakthrough.
Move from requirements and estimation to the building blocks behind scalable systems. Build the design thinking to evaluate and improve an architecture—even when AI helps draft it.
FOUNDATIONS FOR THE AI ERA
Stronger fundamentals. Smarter use of AI.
AI can help you write code. Programming knowledge and logical thinking help you ask better questions, spot incorrect assumptions, debug generated code and judge a solution’s efficiency. Learn the fundamentals so you can build with AI and understand the result.
- Reason before you prompt
- Validate the output
- Own your solution
Your complete learning roadmap.
Download syllabus
Keep the module breakdown, practice assignments and learning outcomes.
Suggested curriculum. Confirm the current batch syllabus, module allocations and total duration with an advisor.
01 Introduction to Web Architecture and Web Fundamentals
- How the Web Works
- Client-Server Architecture
- HTTP/HTTPS
- DNS
- IP Addresses
- Request-Response Lifecycle
- Web Infrastructure
Put it into practice
Trace a full request from browser to server.
What you’ll take away
Explain how the web works end to end.
02 Software Architecture and Architectural Patterns
- Monolithic Architecture
- Layered Architecture
- Client-Server Architecture
- Microservices
- Event-Driven Architecture
- Architectural Trade-offs
Put it into practice
Compare monolithic and microservice designs for one application.
What you’ll take away
Choose architectural patterns based on trade-offs.
03 Distributed Systems Fundamentals
- Distributed Computing
- Fault Tolerance
- Replication
- Consistency
- Availability
- CAP Theorem
Put it into practice
Analyse the CAP trade-offs of real distributed systems.
What you’ll take away
Reason about consistency, availability and fault tolerance.
04 Understanding Application Characteristics
- Functional and Non-Functional Requirements
- Availability
- Reliability
- Latency
- Throughput
- Performance
- Scalability
Put it into practice
Define functional and non-functional requirements for a system.
What you’ll take away
Translate requirements into design goals.
05 Advanced Application Characteristics and Performance
- Load Estimation
- Traffic Patterns
- Capacity Planning
- Bottleneck Identification
- Performance Optimization
- System Design Trade-offs
Put it into practice
Estimate load and capacity for a high-traffic application.
What you’ll take away
Identify bottlenecks and plan for scale.
06 Application Scaling and Database Fundamentals
- Vertical vs Horizontal Scaling
- Load Balancing
- Stateless vs Stateful Services
- Introduction to Databases
- SQL vs NoSQL
- Data Storage Requirements
Put it into practice
Design a horizontally scalable service behind a load balancer.
What you’ll take away
Scale applications and choose suitable databases.
07 Database Architecture and Data Management
- Relational and Non-Relational Databases
- Database Indexing
- Replication
- Sharding
- Partitioning
- Transactions
- Database Scaling
Put it into practice
Design indexing, replication and sharding for a database.
What you’ll take away
Scale and manage data reliably.
08 Communication Protocols and Service Communication
- HTTP/HTTPS
- REST APIs
- WebSockets
- TCP/UDP
- Synchronous vs Asynchronous Communication
- Message Queues
- Pub/Sub Architecture
Put it into practice
Choose communication protocols for a set of services.
What you’ll take away
Design synchronous and asynchronous service communication.
09 Websites vs Web Applications
- Static vs Dynamic Websites
- Websites vs Web Applications
- Client-Side vs Server-Side Rendering
- Application Servers
- CDNs
- Caching
Put it into practice
Compare rendering and caching strategies for a web application.
What you’ll take away
Choose rendering, CDN and caching strategies.
10 Designing a URL Shortener System
- Functional Requirements
- Short URL Generation
- Unique ID Generation
- Database Schema
- Redirection
- Caching
- Scalability
- High Availability
Put it into practice
Design a scalable URL shortener.
What you’ll take away
Apply ID generation, caching and scaling techniques.
11 Designing a Pastebin Application
- Text Storage
- Unique Link Generation
- Expiration Policies
- Database Design
- Object Storage
- Caching
- Scalability
Put it into practice
Design a Pastebin service with expiring links.
What you’ll take away
Design storage and expiry for user content.
12 Designing an API Rate Limiter
- Rate Limiting Requirements
- Token Bucket
- Leaky Bucket
- Fixed Window
- Sliding Window
- Distributed Rate Limiting
- Redis
Put it into practice
Design a distributed rate limiter with Redis.
What you’ll take away
Compare and apply rate-limiting algorithms.
13 Designing a Typeahead Suggestion Service
- Autocomplete Architecture
- Prefix Searching
- Trie Data Structure
- Ranking Suggestions
- Caching
- Indexing
- Low-Latency Search
Put it into practice
Design a low-latency autocomplete service.
What you’ll take away
Design fast, ranked search suggestions.
14 Designing YouTube
- Video Upload and Streaming Architecture
- Video Processing
- Transcoding
- Object Storage
- CDN
- Metadata Management
- Scalable Video Delivery
Put it into practice
Design a video upload and streaming platform.
What you’ll take away
Design scalable media processing and delivery.
15 Designing Dropbox
- File Upload and Download
- Cloud Storage Architecture
- File Chunking
- Synchronization
- Metadata Storage
- Versioning
- Data Consistency
Put it into practice
Design a file sync and storage service.
What you’ll take away
Design storage, sync and versioning systems.
16 Designing a Web Crawler
- URL Frontier
- Crawling Architecture
- URL Scheduling
- Distributed Crawling
- Deduplication
- Politeness Policies
- Fault Tolerance
Put it into practice
Design a distributed web crawler.
What you’ll take away
Design scalable, polite crawling systems.
17 High-Level System Design Case Study and Architecture Review
- End-to-End System Design Approach
- Requirement Gathering
- Capacity Estimation
- Component Identification
- Database Selection
- Scalability
- Architecture Trade-offs
Put it into practice
Design an end-to-end system from requirements to architecture.
What you’ll take away
Present and defend a high-level design.
18 Introduction to Object-Oriented Design and SOLID Principles
- OOP Fundamentals
- Classes
- Objects
- Encapsulation
- Abstraction
- Inheritance
- Polymorphism
- SOLID Principles
- Coupling
- Cohesion
- Introduction to UML
Put it into practice
Model a small system using classes and SOLID principles.
What you’ll take away
Write object-oriented designs that are easy to change.
19 Design Patterns and Software Design Principles
- Creational, Structural and Behavioral Design Patterns
- Singleton
- Factory
- Builder
- Strategy
- Observer
- Decorator
- Common Design Pattern Applications
Put it into practice
Apply design patterns to a real design problem.
What you’ll take away
Choose the right design pattern for each problem.
20 Designing a Meeting Scheduler
- Meeting Creation
- Calendar Management
- Participant Availability
- Scheduling Conflicts
- Notifications
- Recurring Meetings
- Object-Oriented Design
Put it into practice
Design the classes for a meeting scheduler.
What you’ll take away
Model scheduling and availability logic.
21 Designing a Task Planner Application
- Task Creation
- Assignment
- Priorities
- Deadlines
- Task Status
- User Management
- Notifications
- Class Relationships
- Extensible Design
Put it into practice
Design an extensible task planner.
What you’ll take away
Model entities and relationships cleanly.
22 Designing a Bowling Game System
- Bowling Rules
- Frames
- Rolls
- Strike and Spare Calculations
- Scoring Algorithm
- Object Modelling
- Test-Driven Design
Put it into practice
Build a bowling score calculator using test-driven design.
What you’ll take away
Turn rules into tested, well-modelled code.
23 Designing a Snakes and Ladders Game
- Board Representation
- Players
- Dice
- Snakes
- Ladders
- Movement Logic
- Game State Management
- Winning Conditions
- Class Design
Put it into practice
Build a Snakes and Ladders game with clean class design.
What you’ll take away
Model game state and rules with objects.
24 Designing a Facebook Comment System
- Comments
- Nested Replies
- Likes
- Comment Threads
- User Permissions
- Pagination
- Class Relationships
- Extensible Comment Architecture
Put it into practice
Design a nested comment system.
What you’ll take away
Model hierarchical, extensible data.
25 Designing a Sales Manager Application
- Product Catalogue
- Customer Management
- Sales Tracking
- Inventory Management
- Order Processing
- Billing
- Reporting
- Object-Oriented Architecture
Put it into practice
Design a sales and inventory management application.
What you’ll take away
Design object-oriented business applications.
26 Designing a BookMyShow Application
- Movie and Theatre Management
- Show Scheduling
- Seat Selection
- Booking Workflow
- Seat Locking
- Payment Processing
- Concurrency Handling
Put it into practice
Design a movie ticket booking system with seat locking.
What you’ll take away
Handle concurrency in booking workflows.
27 Advanced LLD: Concurrency, Extensibility and Code Quality
- Thread Safety
- Race Conditions
- Synchronization
- Design Pattern Selection
- Exception Handling
- Unit Testing
- Refactoring
- Maintainable Code
Put it into practice
Make a design thread-safe and refactor it for quality.
What you’ll take away
Write concurrent, maintainable code.
28 Low-Level Design Case Study and Machine Coding Practice
- Requirement Analysis
- Class Diagram Creation
- Interface Design
- Implementation
- Design Pattern Application
- Unit Testing
- Machine Coding Interview Practice
Put it into practice
Complete a timed machine coding exercise.
What you’ll take away
Approach LLD interviews with a clear process.
Takeaway from the course
- OOPS and SOLID principles
- Design patterns
- Latency and Throughput
- Databases
- Caching
- Load balancing
- Scaling
- Projects
PUT THE IDEAS TO WORK
Make the concepts
something you can show.
Go beyond isolated concepts. These project ideas bring storage, scale and reliability together in designs you can sketch, stress-test and explain.
Client → LB → API → DBp99: 9 ms
PROJECT IDEA · CONNECTED THINKING
URL shortener
Generate short links, route reads through a cache, and estimate the storage and traffic the service must handle.
Token bucket · Sliding windowTested ✓
PROJECT IDEA · UNDER THE HOOD
Rate limiter
Protect an API from overload, compare token bucket and sliding window approaches, and test the limits.
Rider → Grid cell → DriverMatch found ✓
PROJECT IDEA · LOCATION AT SCALE
Nearby driver finder
Partition a city into grid cells, index moving drivers, and match riders to the nearest one in real time.
Message queueWorkers ready
PROJECT IDEA · RELIABLE DELIVERY
Messaging architecture
Route messages through queues, prioritise urgent work, and keep delivery reliable with retries and idempotency.
Prefix → Trie → Top-KSuggestions ✓
PROJECT IDEA · FIND THE SIGNAL
Search autocomplete
Return suggestions as the user types, cache popular prefixes, and keep latency low under heavy reads.
Illustrative project previews. Your mentor will confirm project scope and review criteria for your batch.
HOW THE LEARNING COMES TOGETHER
Understand it.
Then make it your own.
A learning rhythm that connects the concept, the code and your reasoning. Here’s how you can turn each new topic into a skill.
See the why
Walk through the idea and trace examples. Understand when an approach works and where it falls short.
Design the system
Sketch architectures, estimate capacity, and stress-test your design against scale and failure.
Talk it through
Explain your approach, compare alternatives, and connect your design to its tradeoffs.
Ask your advisor about assignment reviews, doubt support, recordings and mock interview inclusions for your chosen batch.
FIND YOUR LEARNING ENVIRONMENT
Same ambition.
Your way to learn.
Choose the environment that suits your routine. Our advisors can help you compare current batches, schedules and support.
Learn in a classroom.
Bring your questions to class, learn alongside peers, and build a routine around in-person sessions.
Explore Noida & NSP centres Find a classroom batchJoin from where you are.
Attend live sessions remotely. Find a batch whose timing and learning support work for your day.
Live sessions · learn remotely Explore live batches
UP TO100%SCHOLARSHIP
CAST · YOUR OPPORTUNITY TO LEARN
Apply for CAST
Your ambition. A scholarship to match.
Apply for CAST — the Coding Blocks Aptitude and Scholarship Test — and earn a scholarship of up to 100% on course fees.
Available for classroom and Live interactive courses, including Sampoorna. Awards are subject to the test’s eligibility and award terms.
YOUR CENTRE. YOUR SCHEDULE.
Your centre. Your batch.
Choose NSP or Noida, then find the weekday or weekend schedule that fits you.
System Design at NSP, Delhi
No upcoming batches
See the centre
No batches are currently listed for this selection. Contact our team about the next intake.
Talk to an advisor
Your selected batch
A LITTLE CLARITY
Good questions.
Clear answers.
What should I know before joining?
The suggested curriculum assumes you can program in at least one language and understand basic web applications. It starts with design foundations such as requirements, capacity estimation and API contracts before moving into storage, scale and reliability. Tell your advisor about your experience to check your starting point.
How do I choose between classroom and live learning?
Choose classroom learning if you prefer an in-person routine and peer interaction. Live learning lets you attend remotely. Ask about current System Design batch availability, timings and support before choosing your mode.
What will I practise and build?
The suggested roadmap includes design assignments, case studies and project ideas such as a URL shortener and a messaging architecture. Your mentor will confirm project scope, review criteria and the curriculum for your batch.
What are the course duration, timings and fees?
These depend on your selected batch and learning mode. Contact an advisor for the current start date, class schedule, total duration and fees.
Who will teach my batch, and what support is included?
Mentor allocation and support are confirmed with your selected batch. Ask your advisor about doubt sessions, assignment reviews, recording access and mock interview inclusions before enrolling.
Real people. Real milestones.
Our torchbearers.
Just getting started.
Meet Coding Blocks learners whose practice and persistence led to opportunities at leading companies.
Aditya
Iti Jain
Simarpreet Sikka
Vishesh
Jashpreet Malhotra
Walmart
Sahil Bansal
Shervil Gupta
Ashanka Saha
Sandipan Dutta
Lavisha Malik
Manali Biswas
Mohit K.
CODING BLOCKS CERTIFICATE
Skills you’ve built.
An achievement to show.
Celebrate the work you put into system design with a Coding Blocks certificate of completion. Add it to your portfolio and share a milestone in your learning journey. Ask your advisor about the completion criteria for your batch.
-
A record of your completed program
-
A meaningful addition to your portfolio
-
A milestone to share with your network
OUR CLASSROOM CENTRES
Find your classroom.
Right here in Delhi NCR.
Learn with us in Noida or Netaji Subhash Place, Delhi. Find the centre that fits your commute, get directions and come meet the team.
Noida
Sector 2 · Uttar Pradesh
VISIT US
First Floor, A-73, Sector 2,
Noida, Uttar Pradesh 201301
Noida, Uttar Pradesh 201301
CONTACT NUMBER
+91 99995 79111 — call the Noida centre
Near Sector 15 Metro
Get directions to the Noida centre (opens in a new tab)
NSP, Delhi
Netaji Subhash Place · Pitampura
VISIT US
4th Floor, PP Tower, Tower B,
Netaji Subhash Place, Delhi 110034
Netaji Subhash Place, Delhi 110034
CONTACT NUMBER
+91 99993 21553 — call the NSP, Delhi centre
Call us to plan your visit
Get directions to the NSP, Delhi centre (opens in a new tab)
Your next breakthrough
starts with a good design.
Let’s find a System Design batch that fits where you are and where you want to go.