This is one of the most well-organized system design courses I've taken. The instructor focuses on the 'why' behind architectural decisions, not just the 'what.' The real-world case studies like designingYouTube,
WhatsApp, and URL Shorteners are broken down thoughtfully with clear diagrams and trade-offs. Even with prior experience in backend and cloud systems, I found the explanations refreshing.
SYSTEM DESIGN MASTERCLASS
System Design,
Done Right
Learn to design systems that serve millions of people. Work through requirements, APIs, architecture, and the trade-offs behind each decision with engineers who build them.



4.6+ stars · 30,000+ students across our courses
BUILT FOR THE WORK YOU DO
Software engineers
Beginner to senior, with a focus on the decisions mid-level engineers face.
AI engineers
Design the services and data systems your AI features depend on.
Technical leads
Review architecture and explain the trade-offs to your team.
Product managers
Connect product requirements to technical choices.
OUR APPROACH
The 5-Step Interview Framework
Follow one newsfeed design from the first requirement to the final trade-off.
Requirements
Start with what people need from a newsfeed: publish a post, follow someone, and see their latest updates. Then agree on the scale and response times.
What users can do
✓Create text, image, and video posts
✓Follow and unfollow people
✓Read a reverse chronological feed
✓Like and comment on posts
What the system must support
✓500 million daily active users
✓99.999% availability target
✓Feed loads in 1 to 2 seconds
✓Updates visible within 1 to 2 seconds
Capacity Estimation
Estimate how much traffic the feed must handle. The gap between writes and reads explains why we build feeds ahead of time and cache them.
API Design
Give each user action a clear endpoint. Posts store text or a media URL; feed responses return a page of posts with a cursor for the next page.
POST/v1/postsCreate a post with text or a media URLPOST/v1/followFollow a user: followerId + followeeIdGET/v1/feeds/{userId}Read the timeline with cursor-based paginationPOST/v1/commentsAdd a comment to a postHigh-Level Design
Follow a post from the API to your followers’ feeds. Background workers build timelines, a cache serves reads, and the CDN delivers media.
Deep Dive
Now test the design against its hardest cases: a celebrity posts, the cache misses, or a worker fails halfway through fan-out.
Celebrity fan-out
Compare pushing posts to every follower with fetching high-fan-out posts when a feed is read.
Cache misses
Read the stored timeline when a feed is missing from cache, then repopulate it.
Queue retries
Use post IDs to avoid duplicate feed entries when a worker retries a job.
Reliable event delivery
Commit the post and an outbox event together. A relay retries queue delivery so a saved post is not lost between the database and queue.
THE PATTERNS BEHIND THE PRODUCTS
One Template. Every Problem.
The same building blocks connect products with very different requirements.
A GROWING COMMUNITY
Learners Across The Globe
More than 30,000 students enrolled across Sweet Codey courses, from their first system design interview to the next step in their career.
Countries
Students Enrolled
- Across Sweet Codey courses
- New learners joining every week
- From students to senior engineers
Average Rating
- Across Sweet Codey courses
- Reviews from engineers at every level
- Read their experiences below
REAL STUDENTS. REAL REVIEWS.
Trusted by 10,000+ Developers
The biggest plus for me was the clear, consistent framework used across all designs - it helps you know exactly how much to talk about and how to structure your answer in a 40-minute interview. The videos are sized perfectly to show how you'd use existing tools and present a solid design solution. For system design interviews, coming up with a clear, well-structured design is the main priority.
A key strength of the course is that it doesn't just teach how things are built, but also why certain approaches are chosen - and just as importantly, why they are not. This focus on trade-offs cultivates a structured way of thinking. Before this course, I was unfamiliar with many techniques in modern distributed systems. Now I feel equipped with a mental toolkit to approach new scenarios methodically.
The instructors didn't just teach how systems work - they taught how to think like an engineer at scale.
I finally understood how to approach problems like designingTwitter, URL shortener, and rate limiter. The real-life scenarios and trade-offs discussed made a big difference for me. It feels like I'm actually ready to face system design rounds now. Highly recommended if you're preparing for interviews at top tech companies.
I can truly say this is EXACTLY what I was looking for. I spent countless hours onYouTube trying to find resources but nothing was satisfactory or organized. This is a perfect zero-to-one course that teaches design thinking in a way you can remember through standardizations like templates. Amazing job on covering
YouTube and
WhatsApp and especially the quizzes.
The System Design Masterclass changed the way I think about system design. Before, I found the subject boring and confusing, but this course made it interesting and useful. The instructors effectively deconstruct complex concepts and emphasize clear, practical methodologies. The curriculum includes designing real-world systems likeInstagram and
YouTube using a systematic template.
One of the best and most engaging System Design courses I've learned from. The best part is that they follow the same template to approach all HLD problems - this makes every question feel connected with new and specific things added. Waiting for a similar course on LLD too.
This is an amazing course. I am in middle management in big tech and keep my skills sharp by taking design courses periodically. This is a very good course. I would recommend students go through all appendices before diving into individual cases - they have really good information.
SD used to be a boring subject and there are hell lot of courses available - all of them just show PPTs and that's how it gets boring. New Gen Engineers made this subject so awesome that I could understand and clear the interviews. Thank you guys.
Course is detailed with all these designs. I really liked that all the designs followed 1 simple template - functional requirements, non-functional requirements, capacity estimations, API design, HLD, then deep dive. Nobody has ever taught like this. Really loved the course!
Pretty awesome. Earlier, I had no idea about system design. Now I not only understand it, but I'm also clear on the concepts. They're doing a great job!
The course covers everything from fundamental concepts like load balancing, caching, and database sharding to complex distributed systems such as designingYouTube,
Netflix, and
WhatsApp. Real-world scenarios simulate actual interview questions. If you're preparing for FAANG-level system design interviews, this course helps you build a systematic approach.
Really enjoyed this course - it breaks system design down in a way that actually makes sense. TheYouTube and
WhatsApp examples were super helpful, and the framework they teach sticks in your head. Thank you.
This course has been extremely helpful in highlighting the importance of stepping back to look at the system as a whole before implementing new or updating existing features. Highly recommend!
The framework is a game changer, thanks guys!
YOUR LEARNING PATH
Inside the
masterclass.
19 sections, 242 lectures, and 28 quizzes. Work through complete designs, then revisit the fundamentals in the appendices.
11 hours of
system design.
Video lessons, diagrams, worked examples, and quizzes to check your understanding.
01Introduction3 lessons · 18 min+
- Course Introduction3:08
- How this course is structured?3:08
- Framework for System Design Interviews12:14
02Design Instagram Newsfeed27 lessons · 5 quizzes · 63 min+
- Deciding Requirements - Functional Requirements1:12
- Deciding Requirements - Non-Functional Requirements2:01
- Capacity Estimation - Introduction0:30
- Capacity Estimation - Why should you do capacity estimation?4:34
- Capacity Estimation - DAU/MAU0:27
- Capacity Estimation - Throughput2:45
- Calculate ThroughputQuiz
- Quiz Solution: Calculate Throughput3:08
- Capacity Estimation - Storage2:03
- Calculate StorageQuiz
- Quiz Solution: Calculate Storage5:46
- Capacity Estimation - Memory0:29
- Capacity Estimation - Network Bandwidth2:43
- API Design - Create a Text Post2:03
- API Design - Create an Image / Video Post2:27
- API Design - Like / Comment on a Post1:28
- API DesignQuiz
- API Design - Follow / Unfollow another User1:14
- API Design - Read the NewsFeed (aka Timeline)1:20
- High Level Design - Follow / Unfollow another User1:44
- High Level Design - Create a Text Post2:59
- High Level Design - Create a Text Post (Continued)2:40
- High Level Design - Create an Image / Video Post3:59
- Optimizing Media UploadsQuiz
- High Level Design - Read the NewsFeed (aka Timeline)1:48
- High Level Design - Comment on a Post1:23
- High Level Design - Like on a Post1:53
- Deep Dive Insights - Database Selection4:48
- Deep Dive Insights - Data Modeling4:07
- Deep Dive Insights - Pre-Signed URLs1:38
- Deep Dive Insights - Media Processing1:31
- Celebrity AccountsQuiz
03Design Youtube / Netflix16 lessons · 3 quizzes · 38 min+
- Deciding Requirements - Functional Requirements0:53
- Deciding Requirements - Non-Functional Requirements2:02
- Capacity Estimation - DAU / MAU0:16
- Capacity Estimation - Throughput1:22
- Capacity Estimation - Storage0:52
- Capacity Estimation - Memory0:53
- Capacity Estimation - Network Bandwidth2:56
- API Design - Upload Content5:06
- PUT vs POSTQuiz
- API Design - Stream Content4:11
- Streaming Vs DownloadingQuiz
- High Level Design - Upload Content1:17
- High Level Design - Upload Content (Continued)3:36
- High Level Design - Content Processor Workflow Engine5:41
- Time Taking Upload ProcessQuiz
- High Level Design - Stream Content2:43
- Deep Dive Insights - Database Selection2:28
- Deep Dive Insights - Data Modeling1:49
- Deep Dive Insights - HLS Encoding2:05
04Design TinyURL24 lessons · 4 quizzes · 39 min+
- Introduction - What is a Tiny URL Service?0:40
- Introduction - Why do we need a Tiny URL Service?1:01
- Deciding Requirements - Functional Requirements1:08
- Deciding Requirements - Non Functional Requirements1:15
- URL RedirectionsQuiz
- Capacity Estimation - DAU/MAU0:57
- Capacity Estimation - Throughput1:35
- Capacity Estimation - Storage1:02
- Capacity Estimation - Memory0:47
- Capacity Estimation - Network Bandwidth1:47
- API Design - Generate a Short URL2:08
- API Design - Get Long URL back1:10
- High Level Design - Generate Short URL1:36
- High Level Design - Problem: Collisions1:17
- High Level Design - Approach 1: Random String Generation1:15
- High Level Design - Approach 2: Random String Generation using LongURL1:49
- High Level Design - Approach 3: Check DB for Collisions2:29
- High Level Design - Approach 4: Lets Keep Counters2:23
- High Level Design - Approach 4 (Continued): Zookeeper1:09
- High Level Design - Approach 4 (Continued): Base 62 Encoding4:31
- Convert Base 62 to Base 10Quiz
- High Level Design - Approach 4 (Continued): Final Design Diagram1:56
- Problem with Base62Quiz
- High Level Design - Get Long URL1:56
- Deep Dive Insights - Database Selection1:19
- Deep Dive Insights - Data Modeling1:53
- Predictable Short URLsQuiz
- Deep Dive Insights - Redirection from Short URL1:50
05Design Rate Limiter20 lessons · 3 quizzes · 63 min+
- Introduction - Analogy1:35
- Introduction - What is a Rate Limiter?0:40
- Introduction - Why do we need a Rate Limiter?1:10
- Deciding Requirements - Functional Requirements1:04
- Deciding Requirements - Non-Functional Requirements1:26
- Capacity Estimation - DAU / MAU0:53
- Capacity Estimation - Throughput0:42
- Capacity Estimation - Storage & Memory3:06
- Capacity Estimation - Network Bandwidth1:20
- High Level Design - Placement of Rate Limiter4:01
- High Level Design - Basic High Level Design Flow1:33
- High Level Design - Storing Request Counters2:02
- High Level Design - Storing Rate Limiter Rules2:36
- Deep Dive Insights - Rate limiting Algorithms0:35
- Deep Dive Insights - Token Bucket Algorithm8:23
- Quiz - Token Bucket AlgorithmQuiz
- Deep Dive Insights - Leaky Bucket Algorithm7:10
- Quiz - Leaky Bucket AlgorithmQuiz
- Deep Dive Insights - Fixed Window Counter Algorithm4:53
- Quiz - Fixed Window Counter AlgorithmQuiz
- Deep Dive Insights - Sliding Window Log Algorithm8:50
- Deep Dive Insights - Sliding Window Counter Algorithm7:31
- Deep Dive Insights - Handling Race Condition3:13
06Design Whatsapp22 lessons · 7 quizzes · 58 min+
- Deciding Requirements - Functional Requirements1:29
- Deciding Requirements - Non-Functional Requirements0:57
- Capacity Estimation - DAU / MAU0:41
- Capacity Estimation - Throughput3:01
- Estimate Throughput for "Last Seen" featureQuiz
- Capacity Estimation - Storage1:34
- Capacity Estimation - Memory0:42
- Capacity Estimation - Network Bandwidth1:05
- API Design - 1:1 Messaging4:43
- QuizSockets 1Quiz
- API Design - Message Status1:33
- API Design - Online Status2:53
- API Design - Group Messages1:53
- QuizSockets 2Quiz
- High Level Design - How is Websocket Connection established?4:50
- Quiz: WebSocket Handlers and MappingsQuiz
- High Level Design - 1:1 Messaging1:47
- High Level Design - 1:1 Messaging - Offline Client3:27
- High Level Design - 1:1 Messaging - Final Design1:35
- Quiz: Connectivity Challenge - What happens to your messages?Quiz
- High Level Design - 1:1 Messaging (Image, Video, Document)4:05
- High Level Design - Message Status5:31
- High Level Design - Online Status2:46
- High Level Design - Group Messages3:05
- Quiz: Group Chat ChallengeQuiz
- Deep Dive Insights - Database Selection3:40
- Deep Dive Insights - Data Modeling4:16
- Quiz: The Life of a MessageQuiz
- Deep Dive Insights - End to End Encryption2:11
07Design Search Systems17 lessons · 3 quizzes · 57 min+
- Deciding Requirements - Functional Requirements2:44
- Deciding Requirements - Non-Functional Requirements4:46
- Capacity Estimation - DAU / MAU2:11
- Capacity Estimation - Throughput2:26
- Capacity Estimation - Storage2:43
- Capacity Estimation - Memory2:19
- Capacity Estimation - Network Bandwidth3:39
- API Design - Search3:03
- Quiz: Search URL EncodingQuiz
- High Level Design - Search (Suboptimal)2:48
- High Level Design - Search (Indexing)2:50
- Quiz: Revisit Capacity Estimation (Index DB)Quiz
- High Level Design - How to Support Fuzzy Search?3:21
- High Level Design - Search (Ranking)4:18
- High Level Design - Search (Final Design)4:14
- Deep Dive Insights - Database Selection5:42
- Deep Dive Insights - Data Modeling3:32
- Deep Dive Insights - Query Correction Service5:01
- Quiz: Query Correction & Levenshtein DistanceQuiz
- Deep Dive Insights - Elastic Search1:52
08Design Airbnb20 lessons · 3 quizzes · 58 min+
- Deciding Requirements - Functional Requirements1:42
- Deciding Requirements - Non-Functional Requirements1:09
- Capacity Estimation - DAU / MAU0:52
- Capacity Estimation - Throughput2:22
- Capacity Estimation - Storage2:07
- Capacity Estimation - Memory0:33
- Capacity Estimation - Network Bandwidth3:39
- API Design - Add Property (Property Owner)2:23
- Quiz: Design API for Update PropertyQuiz
- API Design - View Bookings (Property Owner)2:33
- API Design: Search Properties (Guest)2:18
- API Design - View Property (Guest)1:48
- API Design - Book Property (Guest)6:19
- Quiz: From Booking to Payment to ConfirmationQuiz
- Quiz: Design View Bookings API for GuestQuiz
- High Level Design - Add / Update Property (Property Owner)4:57
- High Level Design - Search Properties (Guest)4:57
- High Level Design - View Property (Guest)1:40
- High level Design - Book Property3:45
- High Level Design - View Bookings0:55
- Deep Dive Insights - Database Selection3:53
- Deep Dive Insights - Data Modeling3:11
- Deep Dive Insights - Handling Concurrent Bookings6:36
09Design Notification System20 lessons · 69 min+
- Introduction - What is a Notification System?1:35
- Introduction - Why do we need a Notification System?2:08
- Deciding Requirements - Functional Requirements3:33
- Deciding Requirements - Non-Functional Requirements5:35
- Capacity Estimation - DAU / MAU2:24
- Capacity Estimation - Throughput3:31
- Capacity Estimation - Storage3:30
- Capacity Estimation - Memory0:41
- Capacity Estimation - Network/Bandwidth1:59
- API Design - Send Notification3:29
- High Level Design - Basic High Level Flow10:20
- High Level Design - Problems with Basic High Level Design4:12
- High Level Design - Validation and Prioritization1:54
- High Level Design - Rate Limiting Notifications1:15
- High Level Design-Adjusting to User Preferences2:55
- High Level Design- Handling different types of Notifications4:31
- High Level Design Reorganizing services4:06
- High Level Design- Decoupling5:39
- Deep Dive Insights: Database Selection3:14
- Deep Dive Insights-Database Modeling2:56
10Design Distributed logging11 lessons · 39 min+
- Introduction3:47
- Deciding Requirements - Functional Requirements3:42
- Deciding Requirements - Non Functional Requirements3:36
- High Level Design -Client Request and Correlation ID1:15
- High Level Design -Collecting Logs on each Service2:08
- High Level Design - Kafka for buffering2:19
- High Level Design - Processing with Flink4:14
- High Level Design - Storage Backends5:21
- High Level Design - Query and Dashboards3:47
- Deep Dive Insights- Protobuf and Aro Serialization3:59
- Deep Dive Insights- Flink4:51
11Design OTP Service12 lessons · 42 min+
- Introduction2:30
- Deciding Requirements3:09
- Capacity Estimation - Throughput2:28
- Capacity Estimation - Memory/Storage1:29
- API Design - Generate OTP4:47
- API Design - Validate OTP1:52
- High Level Design - Generate OTP4:03
- High Level Design - Generate OTP Questions3:47
- High Level Design - Verify OTP1:49
- Deep Dive - Cache Selection2:22
- Deep Dive - Securing OTP5:16
- Deep Dive - High Availability8:23
12Appendix - The Ultimate System Design Template11 lessons · 18 min+
- Client & Server1:40
- Database2:47
- Vertical vs Horizontal Scaling1:57
- Load Balancer1:42
- Database Sharding1:14
- Database Replication0:59
- Cache1:45
- Content Delivery Network (CDN)1:49
- Monolith & Microservice1:31
- Message Queue1:38
- API Gateway0:59
13Appendix - Design Goals Buzzwords5 lessons · 7 min+
- Introduction0:27
- Scalability1:22
- Availability0:59
- Consistency - Strong / Eventual2:38
- Fault Tolerance / No SPOF1:43
14Appendix - Networking Buzzwords9 lessons · 11 min+
- IP Address1:31
- DNS - Domain Name Service1:30
- Client & Server1:37
- Protocols - Introduction0:34
- Protocols - TCP0:42
- Protocols - UDP1:24
- Protocols - HTTP0:33
- Protocols - Websocket0:51
- Forward Proxy & Reverse Proxy2:05
15Appendix - Communication Buzzwords5 lessons · 8 min+
- Introduction0:47
- GraphQL1:41
- gRPC1:43
- Message Queues2:18
- Rest API1:04
16Appendix - Database & Storage Buzzwords7 lessons · 13 min+
- Introduction0:35
- Relational Database / SQL Database1:28
- Non-Relational Database / NoSQL3:03
- SQL vs NoSQL3:02
- Object Storage0:57
- Cache2:18
- CDN - Content Delivery Network1:35
17Appendix - Caching Deep Dives4 lessons · 17 min+
- Read Caching Strategies3:17
- Write Caching Strategies2:19
- Read Cache Strategies - Pros and Cons4:23
- Write Cache Strategies - Pros and Cons6:32
18Appendix - Extra Buzzwords4 lessons · 10 min+
- Cloud Computing4:20
- Logging & Monitoring3:28
- Hashing & Consistent HashingArticle
- CAP TheoremArticle
19Common FAQs5 lessons · 55 min+
- Database Indexing11:28
- Why should you do capacity estimation?4:34
- Apache Kafka Event Streaming7:23
- Beginners guide to Graph QL15:56
- Consistent Hashing15:20
LEARN WITH US
Your instructors.
Learn with the engineers behind Sweet Codey’s system design courses.

Rohit Jain
Software engineer & technical educator
EXPERIENCEHas conducted hundreds of technical interviews. Makes the reasoning behind system design clear and practical.

Suresh Gandhi
Software engineer & technical educator
EXPERIENCE
Builds distributed systems and teaches the concepts, trade-offs, and patterns behind scalable software.

Shubham Chandak
Software engineer at Bloomberg · Co-creator, Sweet Codey
EXPERIENCEShubham teaches system design at Sweet Codey. He is a software engineer at Bloomberg and an IIT Kharagpur alumnus who also studied at the University of Florida.
YOUR NEXT INTERVIEW
Walk in with
a clear approach.
Learn to break down an unfamiliar problem, explain your choices, and build a design you can defend.
Do I need system design experience?+
No. Start with the foundations, then work through real-world system designs. Basic programming and software development knowledge will help.
How is the course structured?+
We use the same five steps throughout: requirements, capacity estimation, API design, high-level design, and deep dive.
Where will I access the course?+
The course is hosted on Sweet Codey’s learning platform. Online enrollment will be available soon.