Through the implementation of a first-come, first-served coupon system, you will solve key real-world backend challenges such as concurrency issues, data consistency, and handling peak traffic. By writing the code yourself, you will identify problems and master essential practical skills, including synchronous/asynchronous processing and queue management. This project-based course is designed to help junior developers and job seekers gain hands-on experience.
813 learners
Level Basic
Course period Unlimited
Reviews from Early Learners
5.0
SPRING
I found the system architecture flow very helpful. Although the course is labeled as beginner-level, the infrastructure used does not seem to be at a beginner level. Personally, I prefer live coding over reviewing AI-generated code, so I liked that aspect. However, I am more familiar with Java, so the Kotlin syntax was unfamiliar to me. I also changed the package names as I pleased before starting the course, and since I ran K6 in a container from Windows Git Bash, the shell script tests actually made the learning process more difficult. Some people may find it convenient to copy and paste the shell script tests, but I personally did not like them. I found the flow of the K6 and shell script tests more difficult to follow than expected, and I feel that I may forget the test flow again when I look at it after some time has passed. Nevertheless, I think it is a good course that will be very helpful to learners from an architectural perspective and in terms of utilizing Redis.
5.0
maruhxn
I hadn't been able to organize the potential issues that occur with large-scale traffic in my head, but this single lecture makes me feel like all my fragmented knowledge is finally coming together. I am so grateful to be able to take a course like this.
5.0
송의진
It was easy to learn in detail while connecting it with hands-on practice. I think it will also be very helpful in practical work.
Techniques for Resolving Concurrency Issues and Ensuring Data Integrity
Traffic load distribution design through synchronous/asynchronous processing
Implementing a Queueing System and Peak Traffic Protection Architecture
When a first-come, first-served coupon event opens, countless requests access the same inventory simultaneously.
More coupons may be issued than the prepared quantity, the same user may receive two, or records across multiple data stores may become inconsistent.
Instead of memorizing a finished architecture, this course has you bring down and redesign a coupon issuance service yourself.
Reproduce the problem, measure TPS, P99, error rates, and actual issuance accuracy, then choose DB locks, Redis, Kafka, caching, and a virtual waiting room, and validate them again under the same load.
Server System Design for Withstanding Traffic Spikes - Coupon Issuance Service
You will write code with Kotlin and Spring Boot.
You will run MySQL, Redis, and Kafka with Docker Compose, and even if Redis and Kafka are new to you, you can follow along step by step if you have a basic understanding of HTTP, RDBs, and Spring Boot.
📌 Continuously evolve a single coupon service from a basic implementation through concurrency, asynchronous processing, caching, consistency recovery, and traffic control.
📌 We repeat the process of reproducing the problem → measuring bottlenecks → choosing a design → revalidating under the same conditions in every part.
📌 We don't look only at TPS and P99. We also verify whether exactly N tickets were issued, whether the one-ticket-per-person rule was followed, and whether every event was stored in MySQL without omission.
📌 We directly compare various alternatives, such as DB pessimistic locks and Redis Lua, and in-memory queues and Kafka, to determine when to choose which.
📌 We don’t stop at theory. Working code, the execution environment, k6 load scenarios, and validation results from before and after the changes are all preserved as one complete set.
Junior backend developers experiencing peak traffic for the first time
This is a great fit for those who feel unsure where to start—whether with the database, cache, or queue—when requests surge.
Backend job seekers who want to develop their system design skills
Recommended for those who want to explain problems, choices, and results through projects instead of simply listing technology names.
Server development learners who want to validate performance with numbers
This will help those who want to take their systems beyond CRUD through load testing and failure reproduction.
You’re already familiar with straightforward implementations but feel unsure where to start investigating and which technologies to choose when traffic surges. This is a great fit for you. By reproducing problems yourself and improving designs based on measurement results, you’ll develop practical criteria for making decisions in real-world situations.
✓ You can implement issuance logic that maintains both accurate quantities and the one-ticket-per-person rule, even with concurrent requests.
✓ You can compare the pros and cons of DB pessimistic locks, Redis distributed locks, and Redis Lua atomic operations, and choose the right approach for each situation.
✓ Separate user responses from database storage with Kafka, and recover failed messages through a DLT and reprocessing flow.
✓ You can detect and respond to Cache Stampede, request surges after a sellout, and inconsistencies between Redis and MySQL.
✓ Connect a virtual waiting room with Gateway Rate Limit to make legitimate users wait and block abusers at the entrance.
✓ In addition to TPS, P99, and error rate, you can measure issuance volume, duplicates, and missing data to demonstrate the results of design improvements.
Reproduce the problem and find the cause through numbers
Intentionally create coupon over-issuance and bottlenecks. Read TPS, P99, error rates, and accuracy metrics, then compare the designs before and after under the same k6 load conditions. Build a basis for your next decision using measurements, not intuition.
Grow through 6 stages, from basic implementation to traffic control
We proceed in the order of implementing coupon requirements, concurrency control, asynchronous processing, caching strategies, consistency recovery, and traffic control. By identifying the limitations of each step, you will naturally understand why the next design is needed.
Connect multiple technologies into a single coupon issuance flow
The Gateway and virtual waiting room control the entry rate, while Redis atomically handles inventory and duplicate issuance. The Kafka Worker saves the data to MySQL, and the batch scheduler checks for inconsistencies between the two data stores.
The code and verification results are preserved together
You will build an application with Kotlin and Spring Boot. Run MySQL, Redis, and Kafka with Docker Compose, then use k6 to apply real-world load and check TPS, P99, error rate, issuance volume, duplicates, and missing records.
A completed architecture may make every choice seem obvious, but in practice you need to identify the cause and choose one option from among several alternatives.
Rather than teaching you how to add yet another popular technology, I wanted to convey the ability to decide where to control requests, where to place each state, and what to use to determine success.
This course does not cover
We won’t broadly cover coupon-adjacent domains like payments and shipping, or all distributed systems theory.
We focus on issuing a predetermined number of coupons, one coupon per person, a set start time, and ending when sold out.
• We use Kotlin, Spring Boot, and Gradle.
• MySQL, Redis, and Kafka are run using Docker Compose.
• We use k6 for load testing.
• You can practice in a Windows, macOS, or Linux environment that can run Docker.
• We recommend at least 8GB of memory for a smooth hands-on experience.
• We provide the lecture slides and complete source code.
(The course is taught in Kotlin, but practice code is provided in both Kotlin and Java versions.)
• We provide execution environments and Docker Compose configurations for each part.
• There are k6 load-testing scenarios you can run repeatedly yourself.
• Review the design documents for each step along with the verification results before and after the changes.
• You need a basic understanding of HTTP and REST APIs.
• We use relational databases and SQL at the level of SELECT and UPDATE statements.
• You should be familiar with Java or Kotlin syntax.
• Basic knowledge of Spring Boot is recommended.
• Experience with Redis and Kafka is not required.
Who is this course right for?
Junior backend developer looking to gain hands-on experience
A backend job seeker who wants to learn concurrency control and handling high-volume traffic
A computer science major who wants to gain hands-on experience designing backend systems at a professional level
Need to know before starting?
Understanding of the basic syntax of backend programming languages (Java, Python, etc.)
Basic Database and SQL Knowledge
Basic Concepts of REST APIs and HTTP Communication
Inflearn Verified
Career Verified
1,895
Learners
72
Reviews
54
Answers
4.9
Rating
7
Courses
Hello, I’m Developer Hanjogak.
Having worked at Kakao and SK, I have designed and operated various backend systems in real-world service environments.
I share the problems and trial and error I encountered along the way, as well as the considerations involved in choosing technologies, through knowledge-sharing content.
From when and why to use a technology to the criteria for designing systems, I want to convey it all within a real-world context.
I hope the challenges and experiences I’ve faced help reduce your trial and error and
make better choices.
If there was anything you were curious about or found lacking while viewing the content, please feel free to let me know anytime.
I want to create better content based on your honest feedback.
Thank you.
All
59 lectures ∙ (10hr 17min)
Course Materials:
All
29 reviews
4.9
29 reviews
Reviews 100
∙
Average Rating 4.9
5
I found the system architecture flow very helpful. Although the course is labeled as beginner-level, the infrastructure used does not seem to be at a beginner level. Personally, I prefer live coding over reviewing AI-generated code, so I liked that aspect. However, I am more familiar with Java, so the Kotlin syntax was unfamiliar to me. I also changed the package names as I pleased before starting the course, and since I ran K6 in a container from Windows Git Bash, the shell script tests actually made the learning process more difficult. Some people may find it convenient to copy and paste the shell script tests, but I personally did not like them. I found the flow of the K6 and shell script tests more difficult to follow than expected, and I feel that I may forget the test flow again when I look at it after some time has passed. Nevertheless, I think it is a good course that will be very helpful to learners from an architectural perspective and in terms of utilizing Redis.
Hello, SPRING! Thank you for leaving such a detailed course review along with a great rating! We’re glad to hear that the course was helpful in understanding the flow of system architecture and how Redis is used, and that you also enjoyed the live-coding approach. At the same time, we understand that the infrastructure topics covered in the course may have felt more difficult than beginner-level material, and we’ll pay closer attention to the difficulty level and course structure going forward. We’ll also take note of your feedback that unfamiliar Kotlin syntax and shell script–based tests may have made the learning process more difficult. Nevertheless, thank you for completing the entire course and leaving such a high rating along with detailed feedback. Based on your comments, we’ll continue improving the course to make it even better. Thank you 🙇♂️
Reviews 9
∙
Average Rating 5.0
Edited
5
[Overall Review] Rather than merely providing an overall introduction to the architecture, this course created problem scenarios and explained the What, Why, and How in depth. I was able to learn not only what to use, but also why it is needed and how to apply it. I mainly use Python, but I am also studying Kotlin and Spring separately, so I had no major difficulty following the course. I personally learned a great deal, and for that very reason, it was difficult to fully digest all the content in a single pass. It was a sufficiently in-depth course that I wanted to watch it at least twice and review the material. In terms of difficulty, it may be a little challenging for beginners, but it is a course worth taking despite that difficulty. [Points for Improvement] I practiced in a Windows environment, and some of the test scripts in the latter part of the course were difficult to run as-is in PowerShell, so I had to modify them and proceed in a different way. I was able to resolve the issues with the help of AI, but it took some time to adapt them to my environment. It would be very helpful if Windows-specific test scripts or execution instructions could be provided separately in the future. I tend to write the code myself in order to understand the logic as thoroughly as possible, so lectures longer than 30 minutes sometimes felt somewhat burdensome to study as a single lesson. Of course, I also understand the intention to explain a single topic without interrupting its flow. It was a great course.
Hello AKBA, thank you for your thoughtful course review! I’m truly glad to hear that you found the course so in-depth that you wanted to review it multiple times. I also think that your effort to understand the logic by writing the code yourself aligned with my intentions in creating the course and was helpful to you. I’ll be sure to take your feedback on the difficulty level and the length of the lectures into account when preparing my next course. Regarding the difficulties you experienced with the Windows exercises, the recent test scripts were prepared to be compatible with Git Bash, but it seems the instructions were not clear enough. I’ll make improvements so that you can more easily find information on how to run them on Windows in the future. Thank you once again for your thoughtful review, and I’m grateful that you described it as a good course 😊
Reviews 236
∙
Average Rating 5.0
5
The lectures are very thorough. I’m impressed that you explain every piece of code, even if only briefly, without glossing over anything. Thank you for the excellent lectures.
Hello, Arale. Thank you for your course review. I tried to explain not only how to write the code by following along, but also why each piece of code is necessary, so I’m glad you appreciated that aspect! Since I explained things one by one, some parts may have felt a bit lengthy, but thank you for engaging with the material so deeply. I hope these explanations will also be helpful when you apply what you’ve learned yourself later on. Thank you 😊
Reviews 13
∙
Average Rating 5.0
5
I hadn't been able to organize the potential issues that occur with large-scale traffic in my head, but this single lecture makes me feel like all my fragmented knowledge is finally coming together. I am so grateful to be able to take a course like this.
Hello, maruhxn. I am truly glad to hear that your fragmented knowledge has been connected into one, as it means the intention behind creating this lecture was well-conveyed. I hope it helped you establish a standard for looking at large-scale traffic issues. Thank you for leaving a review! 😊
Reviews 1
∙
Average Rating 5.0
5
It was easy to learn in detail while connecting it with hands-on practice. I think it will also be very helpful in practical work.
Eujin, thank you for completing the course and even leaving a review! I’m glad to hear that you were able to study comfortably, as the course was designed to help you understand by following along with both explanations and hands-on practice. I hope the experience of implementing and deploying projects yourself in the course will be helpful in your professional work as well. Thank you for staying with me until the end! 😊
Check out other courses by the instructor!
Explore other courses in the same field!
Limited time deal
$5,371.00
23%
$42.90
