Skip to main content
CF

Hands-On High Level System Design Implementation

57h 1m 22s
English
Paid
Added to CourseFlix

Hands-On High Level System Design Implementation is a 23-lesson 57 hours 1 minute self-paced course by Keerti Purswani. Practical High-Level System Design is a course on system design, microservice architecture, and designing distributed systems , aimed at preparing for technical interviews and solving real engineering tasks.

Course facts

Lessons
23
Duration
57 hours 1 minute
Language
English
Added to CourseFlix
November 2026
Instructor
Keerti Purswani
Price
Premium

Practical High-Level System Design is a course on system design, microservice architecture, and designing distributed systems, aimed at preparing for technical interviews and solving real engineering tasks. Instead of learning architecture only from diagrams, you will design, implement, connect, and deploy full-fledged services using AWS, Docker, Kubernetes, Kafka, databases, and Node.js.

About the Course

The program is based around practice: you will first understand the basic components of cloud infrastructure, and then move on to creating large-scale systems, similar in architectural challenges to a messenger like WhatsApp, a video platform like YouTube, and a brokerage platform like Zerodha.

The course helps you understand how solutions from High-Level System Design turn into working applications: from choosing storage and message queues to setting up networks, deploying microservices, monitoring, and observability.

Who the Course is For

  • Backend developers who want to move from developing individual services to designing entire systems.
  • Engineers preparing for System Design and High-Level Design interviews.
  • Developers who want to understand AWS, Kubernetes, Kafka, Docker, and microservice infrastructure in practice.
  • Specialists who need to understand scalability, fault tolerance, data storage, queues, CDN, and service interaction.

What You Will Learn

  • Designing distributed systems at a high level.
  • Microservices architecture and service interaction.
  • Using AWS components to build production-like infrastructure.
  • Working with databases, object storage, CDN, DNS, and network infrastructure.
  • Using Kafka and Amazon MSK for asynchronous event exchange.
  • Containerizing and deploying services with Docker and Kubernetes.
  • Approaches to logging, monitoring, diagnosing, and observing systems.

Course Program

Week 1 — Basics of AWS and Setting Up the Environment

In the first stage, you will be introduced to key services and technologies that are used in building modern scalable systems. This part lays the foundation for subsequent practical projects.

  • EC2 Instances for launching computing resources.
  • Security Groups for managing network access.
  • IAM Roles for setting up permissions and secure access.
  • VPC for organizing network infrastructure.
  • DynamoDB for NoSQL storage.
  • RDS for working with relational databases.
  • S3 for object data storage.
  • CDN and CloudFront for speeding up content delivery.
  • Kafka and Amazon MSK for event architecture.
  • DNS and Route 53 for domain management and routing.
  • Docker for application containerization.
  • Kubernetes for container orchestration.
  • Basics of Node.js for service implementation.
  • Integrating infrastructure components using Node.js.

Weeks 2–3 — WhatsApp-level Messaging System

In this module, you will design and implement a scalable messaging system. The project will help you understand how high-load applications with a large number of users and constant data exchange are built.

Within the project, you will:

  • analyze the High-Level Design architecture of the messenger;
  • design the main services and their zones of responsibility;
  • implement the necessary microservices and components;
  • set up interaction between services;
  • work through message storage and event transmission;
  • combine the separate parts of the system;
  • deploy the complete solution in the cloud.

Weeks 4–5 — YouTube-level Video Streaming Platform

The next project is about designing a platform for video storage, processing, and streaming. You will understand how systems are designed where scalability, content delivery speed, and reliable media file storage are important.

In this module, you will:

  • analyze the architecture of a video streaming platform;
  • design upload, storage, and video delivery services;
  • study the role of object storage and CDN;
  • implement microservice components;
  • integrate the infrastructure into a unified system;
  • deploy the project.

Weeks 6–7 — Zerodha-level Brokerage System

The third major project is about designing a platform for stock market operations. This type of system requires special attention to request processing speed, data integrity, events, and fault tolerance.

You will analyze the High-Level Design of a brokerage platform, implement the key microservices, set up their interaction, integrate components, and deploy the complete solution. Special attention is paid to architectural decisions that may be discussed during system design interviews.

Week 8 — Common Components of Distributed Systems

The final part of the course focuses on infrastructural components essential to practically any production system. You will learn how to track the state of services, identify problems, and maintain the operability of a distributed application.

  • Service and event logging.
  • System state monitoring.
  • Problem diagnosis in distributed architecture.
  • Observability and analysis of service behavior.
  • Review typical questions and complexities that arise during development.

Practical Results After Training

After completing the course, you will have not only theoretical understanding of High-Level System Design but also practical experience in creating several complex distributed systems. You will be more confident in discussing architectural solutions during interviews and better understand how to design services for real-world loads.

  • Experience in designing systems comparable to a messenger, video platform, and brokerage application.
  • Understanding of microservice architecture and service interaction principles.
  • Skills in working with AWS, Docker, Kubernetes, Kafka, databases, and Node.js.
  • Understanding of scaling, data storage, network infrastructure, and content delivery.
  • Practice in deploying and integrating components into a single system.

Why Study High-Level System Design in Practice

In system design interviews, it is important not just to know the names of technologies, but to be able to explain compromises: which database to choose, where to use a message queue, how to scale a service, how to ensure fault tolerance, and how to monitor the system after launch.

This course helps link architectural concepts with real development. You will see how design decisions affect code, infrastructure, deployment, and application operation.

Who teaches Hands-On High Level System Design Implementation? Keerti Purswani

Keerti Purswani thumbnail

Kirti creates clear and practical educational materials on artificial intelligence and machine learning. Her goal is to make complex topics accessible to everyone, so the content is suitable for both beginners and experienced developers.

What the content includes

  • tutorials and code reviews;
  • technical interview practice;
  • practical tips for interview preparation;
  • explaining modern technologies in simple language.

Author's online courses

Kirti conducts online courses in key areas of development and AI, including:

  • software systems architecture HLD / LLD;
  • data structures and algorithms;
  • modern C++;
  • project development (MERN, DevOps, AWS);
  • generative artificial intelligence.

More than 8,000 students have participated in her trainings.

What lessons are included in Hands-On High Level System Design Implementation?

This is a demo lesson (10:00 remaining)

Watch the first 10 minutes free. One payment unlocks all 23 lessons here and every other premium course. No auto-renew.

View Pricing
0:00
/
#1: Day 1 - Intro to AWS - Regions, AZs, VPCs, Subnets, EC2
All Course Lessons (23)
#Lesson TitleDurationAccess
1
Day 1 - Intro to AWS - Regions, AZs, VPCs, Subnets, EC2 Demo
02:40:32
2
Day 2 - Intro to NodeJS, Express, Load Balancers, Docker
02:24:19
3
Day 3 - Docker, Kubernetes, ECS, S3
02:53:16
4
Day 4 - Chat App Project Basic Functionality using Websockets
02:26:20
5
Day 5 - MongoDB, Auth, JWT
02:56:46
6
Day 6 - Login, Routing and more
02:14:08
7
Day 7 - Zustand, Socket Map, Msgs in MongoDB
02:15:18
8
Day 8 - API Gateway, 1-1 msging, Containerization, Redis
02:33:26
9
Day 9 - DockerHub, PubSub, ECS
02:40:34
10
Day 10 - ECS, CICD, GitHub Actions, NextJS CSR, SSR
02:40:53
11
Day 11 - YouTube Project Basic Flow, Intro to ABS, OAuth
02:32:47
12
Day 12 - NextAuth, SSO, Kafka
03:01:54
13
Day 13 - Chunking, Multipart upload
02:11:17
14
Day 14 - DB Discussion, VideoMetaData in Postgres, Prisma
02:38:33
15
Day 15 - Transcoding, CDN, Project HLD Dicussion
02:43:17
16
Day 16 - ELK Stack, OpenSearch & Lambda in YouTube Project
02:35:40
17
Day 17 - Search in YouTube FE, Intro to Stock Broker, gRPC
02:14:34
18
Day 18 - GraphQL, Upstox API, WebHooks
03:02:33
19
Day 19 - Watchlists Flow, Search Stocks - OpenSearch &. Lambda
02:01:21
20
Day 20 - Upstox API, gRPC
02:03:46
21
Day 21 - Stock Broker Project Completion, HLD Discussion
01:55:52
22
Day 22 - CAP Theorem, Capacity Estimation, Interview Prep Tips
02:05:31
23
Day 23 - Notifications, Kubernetes, EKS, Prometheus
02:08:45
Watch the other 22 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

What courses are similar to Hands-On High Level System Design Implementation?

More courses by Keerti Purswani

  • Agentic AI System Design thumbnailUpdated 1mo ago

    Agentic AI System Design

    A practical course on building agent-based AI systems, RAG architecture, context engineering, and LLMOps for developing reliable enterprise solutions.
    35h 30m5/5

Frequently asked questions

What is Hands-On High Level System Design Implementation about?
Practical High-Level System Design is a course on system design, microservice architecture, and designing distributed systems , aimed at preparing for technical interviews and solving real engineering tasks. Instead of learning…
Who teaches this course?
It is taught by Keerti Purswani. You can find more courses by this instructor on the corresponding source page.
How long is the course?
It contains 23 lessons with a total runtime of 57 hours 1 minute. Every lesson is available to watch online at your own pace.
Is it free to watch?
It is part of CourseFlix's premium catalog. A subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch it online?
The course is available to watch online on CourseFlix at https://courseflix.net/course/hands-on-high-level-system-design-implementation. The page hosts every lesson with the integrated video player; no download is required.