The Easiest and Most In-Depth MongoDB Complete Guide [ By. Non-CS Major & Kakao Developer ]

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.

Learn how to design and process large-scale data architecture that handles hundreds of billions of data records using only pure SQL and MySQL's core features, together with a Toss developer who handles hundreds of billions of financial traffic transactions and a developer who started as a non-major and is now developing platforms in Pangyo.

Learn SAGA transaction management techniques for maintaining data consistency in distributed environments through hands-on practice. Build 3 microservices using Spring Boot and Docker, and implement both Orchestration and Choreography patterns with Kafka and MySQL. Through this course, you can master core concepts that are immediately applicable in real-world scenarios, including distributed transaction operation principles, compensating transaction design, and failure recovery handling.

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.

Kotlin mastery via virtual payment server course.

Develop a scalable order processing system with real-time event streaming capabilities using Spring Boot 3.x + Kotlin to build a Kafka cluster, leveraging PostgreSQL CDC, Debezium Connect, and Apache Avro schema.

When you're doing backend development, at some point you face this dilemma. As services grow and traffic increases, there comes a moment when simple REST communication and CRUD structures feel limiting. I experienced the same problem in real-world work and went through many trials and errors between performance and structural complexity. The solution I chose in that process was NATS. Its simple configuration based on a single binary, ultra-low latency performance in microseconds, and the fact that it provides just the right amount of essential features for real work—from Pub/Sub to Queue Groups and JetStream—made it a very practical choice in actual service environments. This course is not about listing NATS features. Based on the problems I faced in real work, I explain with code and flow diagrams which situations led me to choose NATS, why, and how I designed the architecture. This is a course designed to help everyone—from those new to messaging systems, to backend developers preparing for jobs, to senior developers contemplating better architectures—understand distributed systems and grow to the next level.

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

I'll show you how to use Redis effectively, along with its precautions and best practices, using real-world examples from actual work environments and well-known case histories.

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.

In this course, rather than directly covering theory, you will learn how to effectively use Redis in code through hands-on practice.

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

How do you handle exploding traffic? Learn how to build resilient and flexibly scalable architectures through practical design patterns based on EDA (Event-Driven Architecture) using Kafka, Spring, CDC, and Temporal. Explained clearly and simply with real-world experience from a Kakao developer, making it accessible even for non-majors. A hands-on, practical course covering real-time data flow, event processing, and microservice integration all at once!

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.

Let's build a project using Ktor, the most popular project in Kotlin, and master Kotlin! 😆

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.

How do you handle exploding traffic? Learn how to build resilient and flexibly scalable architectures through practical design patterns based on EDA (Event-Driven Architecture) using Kafka, Spring, CDC, and Temporal. Explained clearly and simply with real-world experience from a Kakao developer, making it accessible even for non-majors. A hands-on, practical course covering real-time data flow, event processing, and microservice integration all at once!

Learn database design systematically through three stages: conceptual, logical, and physical, and strengthen your capabilities with a practical shopping mall project. Acquire real-world expertise through modern design techniques and the latest trends.

I have created a 'DB Design: Introduction & Practice' course that is easy for non-majors to understand and can be applied immediately in the real world!

If you have started Java development but feel overwhelmed when trying to solve a problem, it is time to study design patterns. I will explain 10 of the GoF design patterns that I personally use the most.

Inflearn cumulative students over 30,000, Datarian's SQL basics course with rich online/offline teaching experience. Learn SQL basic theory and solve 10 SQL problems together.

Learn SAGA transaction management techniques for maintaining data consistency in distributed environments through hands-on practice. Build 3 microservices using Spring Boot and Docker, and implement both Orchestration and Choreography patterns with Kafka and MySQL. Through this course, you can master core concepts that are immediately applicable in real-world scenarios, including distributed transaction operation principles, compensating transaction design, and failure recovery handling.

Introduction to SQL Data Analysis! Quick and easy to understand with practical problem solving!

Inflearn's SQL intermediate course by Datarian, with over 30,000 cumulative students and extensive online/offline teaching experience. Learn intermediate SQL theory and solve 20 practice problems together.

Databases and SQL are essential for backend developers! We prioritize explaining them in an easy-to-understand manner.

This course teaches MS-SQL through baseball/company databases.

This is a lecture for people who are starting development for the first time. It's about programming thinking, which should come before development languages or UI frameworks.

If you are a student or developer who is using or studying the Java programming language, you will learn various methods of testing your applications that you must know.

Let's create a hearing aid app using Android Studio App. I will share the project preparation and progress process so that it can be helpful to those preparing for the contest with the work that won the contest.

When you're doing backend development, at some point you face this dilemma. As services grow and traffic increases, there comes a moment when simple REST communication and CRUD structures feel limiting. I experienced the same problem in real-world work and went through many trials and errors between performance and structural complexity. The solution I chose in that process was NATS. Its simple configuration based on a single binary, ultra-low latency performance in microseconds, and the fact that it provides just the right amount of essential features for real work—from Pub/Sub to Queue Groups and JetStream—made it a very practical choice in actual service environments. This course is not about listing NATS features. Based on the problems I faced in real work, I explain with code and flow diagrams which situations led me to choose NATS, why, and how I designed the architecture. This is a course designed to help everyone—from those new to messaging systems, to backend developers preparing for jobs, to senior developers contemplating better architectures—understand distributed systems and grow to the next level.

The flower of Java programming, object-oriented programming! Concepts and practice. We will teach you at the same time.

This course focuses more on data modeling through entity design than on JPA technical explanations. Based on the principle that solid DB design is the foundation of application development, we analyze various design patterns—such as one-to-many, many-to-many, inheritance, and collections—alongside business scenarios. You will learn by directly observing the process of code being transformed into actual tables on screen. To ensure immediate practical application, we provide business use cases, source code, and test codes for each design pattern.

Java is not difficult to learn. It's just that it becomes difficult because you learn too many unnecessary things. There are things in technology that can only be understood when you reach that stage. But, it's just hard because you try to cram too much unnecessary stuff into your head. Technology is experience. Let's learn quickly and simply!!

By implementing various practical data analysis cases using SQL, you can simultaneously improve your data analysis and SQL utilization skills.

From understanding SQL to using actual functions, Complete preparation for SQLD certification with the latest past exam questions!