GraphQL for Document-Based Framework Communication Patterns: Insights from a Kakao Interviewer

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.

This course goes beyond basic CRUD-level database operations, equipping you with practical PostgreSQL skills essential for the AI era from a real-world perspective. Drawing on AI development experience in Silicon Valley, you will learn step-by-step how to design and leverage JSON, indexing, transactions, and pgvector in actual production services, and master the techniques to resolve complex data structure and performance issues.

When operating a batch system that processes millions of records, the most significant challenges are performance degradation and the difficulty of recovery in the event of a failure. These issues cannot be resolved with simple loops or flawed designs. Drawing on extensive experience in reliably processing large-scale data in real-world service environments, this course will guide you through the structure and mechanics of Spring Batch, teaching you how to design systems that achieve both high performance and robust stability. Going beyond mere feature explanations, it equips you with a practical batch architecture that can be immediately applied in the field, helping you develop fundamental problem-solving skills for data processing.

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.

It was created to solve the daunting problem of "not knowing where or how to start with Kubernetes." Drawing on hands-on experience from operating financial infrastructure, this material is structured to walk you through actual deployment and operational workflows, moving beyond mere theory. Through a comprehensive learning path covering its relationship with Docker, YAML, Pods, Deployments, and Services, learners will master Kubernetes not just as an 'abstract concept', but as a 'practical, usable technology'.

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 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.

This course is designed for developers seeking fundamental solutions in environments where increasing traffic slows down response times, thread pools are quickly exhausted, and bottlenecks worsen as external API calls multiply. Rather than simply scaling out servers, it helps you approach problems from the perspective of fundamentally restructuring your architecture. 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 fails to increase even when CPU resources are available, and exactly how blocking I/O consumes 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. Going beyond basic usage, you will gain hands-on experience in understanding how data flows are initiated, consumed, and how throughput is regulated. In particular, you will directly implement design patterns that leverage Backpressure to prevent OOM errors and system overload. Additionally, you will explore the event loop-based processing architecture of Spring WebFlux and engage in comparative exercises to see how Non-Blocking I/O operates during actual request processing. By placing MVC and WebFlux side by side, you will identify their structural differences and establish clear criteria for deciding when to adopt a reactive approach. This course goes far beyond simply "learning asynchronous programming." You will learn how to handle more requests with fewer threads, maintain stable data flows in environments heavily dependent on external APIs, and develop the architectural intuition needed to maximize throughput in high-concurrency environments.

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.

Systematically learn the distributed NoSQL database Cassandra, from foundational concepts to real-world applications. Build your large-scale data processing skills through hands-on practice and practical theory covering data modeling, query optimization, and cluster configuration. Even without prior database experience, you can become a Cassandra expert by learning from the practical know-how of a Silicon Valley developer.

This course goes beyond merely teaching how to use Docker as a tool; it approaches the subject from the perspective of solving real-world challenges and problems encountered in actual practice. Drawing on firsthand experience operating financial infrastructure in the field, the course explains how to tackle unpredictable errors caused by discrepancies between development and production environments, configuration mistakes stemming from a vague understanding of images and containers, and even the anxiety of wondering, "How much do I really need to know to be competent in the real world?" Rather than simply listing commands, it focuses on real-world case studies to explore why such architectures are necessary, how to design images for easier maintenance, and how to manage containers for stable service operations. In particular, by emphasizing hands-on practice over theory, the course is designed to help students grasp concepts visually and master them through practice, elevating their skills from merely "knowing how to use" Docker to truly "understanding it from an operational perspective." This course provides practical benchmarks and clear direction for those encountering Docker for the first time, those who have used it but lack a solid grasp of the underlying concepts, and developers looking to take their infrastructure skills to the next level.

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.

This Redis course was developed in collaboration with a current Kakao interviewer. It covers hands-on practice with data structures ranging from Strings to Sorted Sets, as well as Sentinel and Cluster configuration, equipping you with the design rationale needed to excel in both technical interviews and real-world scenarios.

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 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.

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.

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.

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 explores MSA design patterns, implementation strategies, and various content crucial for microservice application development. You will acquire core knowledge and practical methods for successfully converting existing monolithic applications to MSA. You will analyze diverse design patterns underpinning microservice architecture, learning their suitable contexts and application methods.

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 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 Redis course was developed in collaboration with a current Kakao interviewer. It covers hands-on practice with data structures ranging from Strings to Sorted Sets, as well as Sentinel and Cluster configuration, equipping you with the design rationale needed to excel in both technical interviews and real-world scenarios.

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.

Document writing is the most challenging part for both aspiring and current developers! Create your own portfolio by looking at how successful candidates write their documents! We speak based only on documents that actually passed!

Learn about the uses, pros and cons of various design patterns while creating a drawing board with TypeScript/JavaScript. Learning the canvas API is a bonus!

We will completely resolve the anxiety of those who felt frustrated by blindly copying AI-generated code without understanding the internal workings of HTTP or the causes of unexpected hanging.

You can quickly experience the process of deploying a sample e-commerce service to AWS and continuously improving it into a robust and efficient environment.

Faster than anyone else, Electron Todo List With TypeScript Create a React-based desktop service using Electron developed with TypeScript!

In many programming languages, including Javascript, asynchronous operations are one of the most difficult and complex elements of software. You can discard primitive asynchronous programming such as setTimeout and setInterval and easily handle complex asynchronous operations through RxJS.

Preparing for a coding interview? You've come to the right place! We've put together a session to dive deep into those JavaScript concepts that are usually hard to understand or remain confusing no matter how many times you hear them :) Are you ready to capture the interviewer's heart?

I have created a 'Kubernetes Introduction/Practice' course that is easy for non-majors to understand and can be applied immediately in the field!

We have created this so that anyone can pass the 2023 version of the Web Design Function Exam Criteria. Let's learn the 5 types and pass quickly!

The days of feeling relieved by black-box code spat out by AI are over. By piercing through the physical limitations of computers and the inner workings of the Node.js core engine, we provide you with the engineering control to remain unshakable in the face of any traffic surge.

This course aims to cover the latest Gemini API SDK (@google/genai) in a Node.js and TypeScript environment. You will learn how to use multimodal technology to process text, images, and video simultaneously. We will practice the entire process, from issuing an API key to project setup and model calling.

This is a highly concentrated Typescript grammar lecture that will turn you into a Typescript grammar expert with just one lecture, even if you don't know anything about Typescript.

We teach you the core principles of clean code through easy example code.

We have entered an era where it has become incredibly easy for web developers (especially React developers) to launch apps. With Expo, you can release both Android and iOS apps even faster. Let's become developers who can quickly launch apps through Expo.

In this lecture, you will learn how to use OpenTracing to perform distributed tracing across various applications.