Kubernetes for Toss Developers Operating Financial Infrastructure

This course goes beyond simply teaching you how to use Docker as a tool; it approaches the subject from the perspective of solving the real-world dilemmas and problems encountered in professional practice. From unpredictable errors caused by differences between development and production environments, to configuration mistakes stemming from vague concepts of images and containers, and even the anxiety of "how much do I need to know to survive in the field"—this course explains it all based on firsthand experience operating financial infrastructure. Rather than just listing commands, it focuses on real-world cases: why certain structures are necessary, how to design images for easy maintenance, and how to handle containers for stable service operation. In particular, by prioritizing hands-on practice over theory, the course is designed to elevate students from simply "knowing how to use" Docker to "understanding it from an operational perspective" through visual comprehension and direct experience. This course provides practical standards and direction for those new to Docker, those who have used it but lack a clear conceptual grasp, and developers looking to take their infrastructure intuition to the next level.

This course goes beyond simple CRUD-level database usage to help you acquire PostgreSQL skills necessary for the AI era from a practical perspective. Based on AI development experience in Silicon Valley, you will learn step-by-step how to design and utilize JSON, indexes, transactions, and even pgvector in real-world services, while mastering methods to solve complex data structures and performance issues.

This course covers how to set up multi-module projects from scratch using Kotlin and Spring Boot. It proceeds with a hands-on approach, covering everything from the basic concepts of modularization to Gradle configuration, managing dependencies between modules, and actual application development. If you are a beginner or intermediate developer looking to learn the fundamentals and practical application of multi-modules, please refer to this course.

Develop a scalable real-time WebSocket chat server capable of handling high traffic by building a 3-instance cluster with Spring Boot 3.x and Kotlin, utilizing Redis Pub/Sub for distributed messaging and Nginx as a load balancer.

Learn the process of building essential Observability in a Microservices Architecture (MSA) environment from basics to practical application. Master standardized data collection using OpenTelemetry, trace storage and search through Grafana Tempo, and visualization using TraceQL through step-by-step hands-on practice. You can learn how to track service flows through distributed tracing, identify bottlenecks, and analyze the root causes of failures.

This course is a master class that teaches Kotlin's 🌺 Coroutine, covering everything from theoretical foundations to practical application in a standard manner. It systematically covers core principles and structure, the necessity of asynchronous programming, Coroutine builders and scopes, exception handling, channels, Flow, and other key features frequently used in practice, step by step. Each concept is explained with hands-on examples, making it easy for beginners to understand and immediately apply them. This is the best introductory and practical course for developers who want to build strong Coroutine skills for real-world use.

This course focuses on solving the problem of getting stuck in interviews and practical work due to a lack of understanding of why certain structures and configurations are necessary, rather than just teaching how to configure NGINX. Based on experience evaluating numerous candidates as an interviewer for companies like Naver, Kakao, and Toss, I explain how to describe and utilize NGINX from the perspectives of performance, scalability, and operations through hands-on practice. The core of this course is to help you develop a mindset capable of tracing traffic flow and troubleshooting problems, rather than just memorizing configuration values.

Most developers are still stuck on Batch and CronJobs when it comes to data processing. However, in real-world production environments, data is generated continuously, and failing to process that flow immediately leads to latency, bottlenecks, and consistency issues. Having personally dealt with real-time recommendations, state synchronization, and event delay problems in high-traffic environments, I’ve often asked myself, "Is batch processing really the right approach for this?" This course begins with that very question. It explores how to use Apache Flink to perform computations the moment data flows, manage state securely, and produce accurate results based on Event Time—all from a practical perspective. Beyond simple theoretical explanations, you will experience how real-time stream processing systems are designed and operated through actual source code and architectures. For those who found real-time processing vague or were curious about the world beyond messaging, this course will provide a clear sense of direction.

Learn the SAGA transaction management technique for maintaining data consistency in distributed environments through a hands-on approach. You will configure three microservices using Spring Boot and Docker, and implement both Orchestration and Choreography patterns using Kafka and MySQL. Through this course, you will master core concepts applicable to real-world scenarios, including the operational principles of distributed transactions, designing compensating transactions, and handling fault recovery.

How will you handle exploding traffic? Learn how to build resilient and flexibly scalable architectures through practical EDA (Event-Driven Architecture) design patterns using Kafka, Spring, CDC, and Temporal. A Kakao developer shares real-world experience with clear, easy-to-follow explanations that even non-majors can understand. A practice-oriented course covering everything from real-time data flow and event processing to microservice integration!

This course provides a step-by-step learning path, ranging from the fundamental usage of MySQL to advanced techniques required in real-world production environments. It covers a wide range of topics, including data modeling techniques based on various case studies and practical data, evaluating the effectiveness of Foreign Key designs, analyzing Google Calendar schema DDL, and modern DDL design principles. Through this course, you will gain an in-depth understanding of how to utilize MySQL as a core system component rather than just a simple database.

Build a scalable real-time event streaming order processing system using Spring Boot 3.x + Kotlin, establishing a Kafka cluster, and leveraging PostgreSQL CDC, Debezium Connect, and Apache Avro schemas.

The biggest challenges in operating batch systems that process millions of records are performance degradation and the difficulty of recovery in the event of a failure. These issues cannot be solved with simple loops or poor design. Based on my experience of reliably processing large-scale data in real-world service environments, this course covers the structure and operating principles of Spring Batch and provides design methods to achieve both performance and stability. Moving beyond simple functional descriptions, this course will help you develop fundamental data processing problem-solving skills through batch architectures that can be applied immediately in practice.

This course is for developers who want to find fundamental solutions in environments where response times slow down as traffic increases, thread pools are quickly exhausted, and bottlenecks worsen with more external API calls. It helps you look at problems from the perspective of changing the architecture itself, rather than simply scaling out servers. Through this course, you will first understand the limitations of the traditional Spring MVC "Thread per Request" model. You will examine at the code level why throughput doesn't increase even when CPU resources are available, and exactly how blocking I/O occupies system resources. Next, you will learn the concepts and standard specifications of Reactive Streams and master how to handle data streams using Reactor's Mono and Flux. Beyond simple usage, you will learn through hands-on practice how data flows start, how they are consumed, and how throughput is controlled. In particular, you will directly implement design patterns that prevent OOM (Out of Memory) or overloads using Back Pressure. Additionally, you will understand the event loop-based processing structure of Spring WebFlux and conduct comparative exercises on how Non-Blocking I/O operates during actual request processing. By placing MVC and WebFlux side-by-side to verify their structural differences, you will also establish criteria for when to choose Reactive. This goes beyond simply "learning asynchrony." You will learn how to handle more requests with fewer threads, how to maintain a stable flow in environments with high external API dependencies, and develop the design intuition to secure throughput in high-concurrency environments.

You may have felt frustrated using Redis without being able to explain why it should be designed that way or why certain patterns emerged. Through my experience in both practical development and as an interviewer, I have treated Redis not just as a simple cache, but as a core component that determines service stability and scalability. This course is not about memorizing commands; instead, I will share my experiences on which structures to choose in real traffic environments and their trade-offs, helping you establish the criteria to explain these concepts confidently in both interviews and practical work.

This course was created to solve a common problem many people face while preparing for developer jobs: "I studied CS and data structures, but I get tongue-tied during interviews." While conducting actual interviews at companies like Naver, Kakao, and Toss, I noticed that most candidates have memorized concepts but cannot explain why those concepts are necessary or how they are applied in real-world situations. Rather than simple rote memorization, this course teaches you how to understand the interviewer's intent and provide more persuasive answers to the same questions. Whether it's the OSI 7 layers, data structures, or coding tests, we focus on why you need to know them, when they are used, and how to speak about them to receive a positive evaluation in an interview. This course is for those who want to become developers who can explain what they understand in their own words, rather than just giving the same answers as everyone else.

At some point in backend development, you start to have these concerns. It's that moment when services expand and traffic increases, and you begin to feel the limitations of simple REST communication and CRUD structures. I experienced these same issues in the field and went through much trial and error balancing performance and structural complexity. The solution I chose during that process was NATS. Its simple configuration based on a single binary, ultra-low latency performance in microseconds, and the fact that it provides essential features—from Pub/Sub to Queue Groups and JetStream—without being overkill made it a very practical choice for real-world service environments. This course is not just a list of NATS features. Based on the problems I faced in practice, I explain through code and workflows why I chose NATS in certain situations and how I designed the architecture. This course is designed to help everyone—from those new to messaging systems to backend developers preparing for employment and senior developers considering better architectures—understand distributed systems and grow to the next level.

This course explores microservice architecture and distributed environments not as a simple list of technologies, but from a 'design perspective' required in actual work and interviews. Starting from the differences between monolithic and MSA, it progressively covers incremental migration strategies, modular monoliths, clean architecture and hexagonal architecture, clearly explaining why each choice is necessary and the trade-offs involved. Through hands-on practice, you can directly verify the intent of the structure and learn about core issues inevitably encountered in distributed environments—such as data consistency, transactions, inter-service communication, and failure handling—through realistic scenarios. Based on actual questions and perspectives from Kakao interviewers, this course aims to go beyond simple knowledge acquisition and elevate your way of thinking about distributed systems to the next level.

This course covers RPC communication techniques that maximize performance in large-scale MSA (Microservice Architecture) environments. Going beyond simple gRPC practice, you'll learn how to implement stable and efficient inter-service communication in real production environments where hundreds of microservices operate simultaneously. Based on Golang, the course covers Protocol Buffers (proto) syntax writing, automatic code generation and service implementation, gRPC structure and advantages over existing RPC, and performance optimization strategies with a practical focus. To ensure easy understanding for non-majors and server development beginners, the course provides step-by-step explanations from RPC concepts to gRPC's internal operating principles, enabling you to develop practical skills that can be immediately applied to real services.

Learn the process of building data pipelines using Apache Airflow from basics to practical application. Understand Airflow's core concepts and architecture, and master advanced design patterns frequently used in practice such as dynamic DAGs, parallel processing, distributed processing, and Custom Operators through hands-on exercises. Set up a practice environment with Python and Docker, and develop practical skills to design and operate real workflows.

This course goes beyond simply teaching you how to use Docker as a tool; it approaches the subject from the perspective of solving the real-world dilemmas and problems encountered in professional practice. From unpredictable errors caused by differences between development and production environments, to configuration mistakes stemming from vague concepts of images and containers, and even the anxiety of "how much do I need to know to survive in the field"—this course explains it all based on firsthand experience operating financial infrastructure. Rather than just listing commands, it focuses on real-world cases: why certain structures are necessary, how to design images for easy maintenance, and how to handle containers for stable service operation. In particular, by prioritizing hands-on practice over theory, the course is designed to elevate students from simply "knowing how to use" Docker to "understanding it from an operational perspective" through visual comprehension and direct experience. This course provides practical standards and direction for those new to Docker, those who have used it but lack a clear conceptual grasp, and developers looking to take their infrastructure intuition to the next level.

We'll show you a quick and easy way to implement CircuitBreaker to create a fault-tolerant service.

With the price of a chicken combo, you'll learn the deployment process in order: Spring Boot manual deployment -> Docker deployment -> Github Action CI/CD!

You will learn about domain purchase and deploying a Spring Boot production server using EKS, Docker basics, Kubernetes basics, AWS basics, CI/CD automation through GitHub Actions, ArgoCD, and general DevOps topics such as Prometheus/Grafana, etc.

Through this course, you can systematically learn core concepts such as starting and stopping Swarm mode, defining and deploying services (using Docker Compose files), network configuration, volume management, and security considerations.

Learn from the beginning how to set up a development environment that even an ordinary office worker can easily understand. It is practice-oriented and focuses on students learning various development tools such as Vim, VS Code, Git, Docker, and remote development. You can learn how to build an efficient development environment by learning step-by-step from the basic usage of each development tool to advanced functions.

Running MongoDB on Kubernetes is different from simply putting it in a container. There are many things you can only learn by dealing with storage, networking, permissions, and high availability firsthand. This course covers the entire process of configuring and operating MongoDB using the PSMDB (Percona Server for MongoDB) Operator in an AWS EKS environment. The goal is to directly build a production-ready configuration, from cluster setup to Replica Set configuration, backup, and monitoring.

I want to launch a side project as a real service and study Kubernetes, but managed services from AWS/GCP (EKS, GKE, etc.) are too expensive. On the other hand, running it only on a local computer makes it difficult to experience network configurations or actual deployment environments. We will utilize the "Always Free" tier of Oracle Cloud (OCI), which offers the most powerful free benefits among existing public clouds. By installing the lightweight yet powerful k3s, we will build a Linux server and Kubernetes environment capable of hosting actual services from scratch—all at zero cost. After taking this course, you will gain a general understanding of cloud networking and possess your own Kubernetes cluster infrastructure where you can deploy and operate your applications for free.

Regardless of the field! This is a lecture that covers the core fundamentals that developers must know in practice in an easy + code-oriented way. I highly recommend this lecture to all junior developers and job seekers who want to grow.

You may have felt frustrated using Redis without being able to explain why it should be designed that way or why certain patterns emerged. Through my experience in both practical development and as an interviewer, I have treated Redis not just as a simple cache, but as a core component that determines service stability and scalability. This course is not about memorizing commands; instead, I will share my experiences on which structures to choose in real traffic environments and their trade-offs, helping you establish the criteria to explain these concepts confidently in both interviews and practical work.

Learn the SAGA transaction management technique for maintaining data consistency in distributed environments through a hands-on approach. You will configure three microservices using Spring Boot and Docker, and implement both Orchestration and Choreography patterns using Kafka and MySQL. Through this course, you will master core concepts applicable to real-world scenarios, including the operational principles of distributed transactions, designing compensating transactions, and handling fault recovery.

This is a DevOps course based on practical experience in Silicon Valley. It goes beyond theory to cover content that can be applied immediately in the field. You will learn how to develop using Generative AI (Vibe Coding), set up CI/CD tools in a Kubernetes environment, and implement strategies to keep operating costs at $0. We will cover configuring a production environment without additional costs by running DB, Redis, S3, and batch jobs inside Kubernetes, and you will master building automated pipelines using GitHub Webhooks and Jenkins through hands-on projects.

A solo IT startup founder and solo entrepreneur's experience distilled into an honest, straightforward, intuitive, and deep React + Spring Boot course (Docker, AWS, GitHub Actions) I just unified everything into this one course.

Want to work for a long time as a super developer who can handle the entire process of service development and operation on your own? Then build a solid foundation in IT infrastructure knowledge from the ground up, which is just as important as various development languages!

This course focuses on solving the problem of getting stuck in interviews and practical work due to a lack of understanding of why certain structures and configurations are necessary, rather than just teaching how to configure NGINX. Based on experience evaluating numerous candidates as an interviewer for companies like Naver, Kakao, and Toss, I explain how to describe and utilize NGINX from the perspectives of performance, scalability, and operations through hands-on practice. The core of this course is to help you develop a mindset capable of tracing traffic flow and troubleshooting problems, rather than just memorizing configuration values.

Learn cloud infrastructure automation technology using AWS and Terraform, and practice efficient infrastructure management and deployment. Manage AWS resources as code through Terraform, and learn how to deploy consistent infrastructure across various environments.

I've created a cram course that will help you pass the AWS SAA-C03 (AWS Certified Solutions Architect - Associate) certification in just 2 weeks with only 163 questions!

Learn the basic, essential, and practical knowledge of Kafka that software developers need to know. We will integrate Kafka using Spring Boot and conduct hands-on exercises for sending and receiving messages tailored to various real-world scenarios.

Ghost In the N8N - AI Automation Workflow (AI automation flow through the N8N framework) You will gain the foundational knowledge required for practical work and task automation in the AI era, along with guides that can be used immediately in the field!