[Chuseok Special] A Silicon Valley Developer Explains Embeddings and Mini GPT

When Redis alone can no longer guarantee performance, what options do we have?? There is Valkey, which is 100% compatible with Redis and applies IO-based tuning. Through this course, let’s explore how Valkey guarantees 1M++ TPS and learn about the data structures suited to different traffic patterns and feature implementations.

If you’ve ever had trouble determining whether the quality of responses declined after changing a prompt or model while building a service using an LLM, this course may be the solution. You’ll learn how to create your own evaluation criteria and automatically identify responses that have changed.

You know about AI agent frameworks, but understanding how they work and applying them in practice can be difficult, right? Drawing on firsthand experience from Silicon Valley, we’ll guide you from the core principles to practical applications.

The limitations of LLMs? I’ll share practical solutions to real-world problems based on RAG trial and error and operational know-how from working in Silicon Valley.

It was created to solve the problem of “not knowing where or how to start with Kubernetes.” Based on hands-on experience gained from operating financial infrastructure, it is structured to help learners understand Kubernetes by following the actual process of building and operating it, rather than focusing on theory alone. Through a learning progression covering its relationship with Docker, YAML, Pods, Deployments, and Services, learners will internalize Kubernetes not as a “concept,” but as a “usable technology.”

This course goes beyond basic CRUD-level database usage, helping you develop the PostgreSQL skills needed in the AI era from a practical, real-world perspective. Drawing on AI development experience in Silicon Valley, you’ll gradually learn how to design and use JSON, indexes, transactions, and pgvector in actual services, while gaining the skills to solve complex data structure and performance problems.

This course is a master class that systematically covers the fundamental principles and practical applications of MongoDB. Starting with core MongoDB concepts, you will systematically learn essential topics for practical work, such as database design, CRUD operations, indexing, aggregation pipelines, performance optimization, transactions, and security. It explains topics step-by-step so even beginners can understand, and you can deeply learn the working principles of MongoDB through exercises and examples. This is the best introductory and practical course for developers who want to build strong MongoDB skills for practical work.

Most developers still think in terms of Batch and CronJob when discussing data processing. However, in real-world service environments, data is generated continuously, and failing to process that flow immediately leads to delays, bottlenecks, and data consistency issues. I have also repeatedly faced the question, “Is batch processing really the right approach?” while dealing firsthand with real-time recommendations, state synchronization, and event delays in high-traffic environments. This course starts from that very question. It explores, from a practical perspective, how to use Apache Flink to perform computations as data flows in, manage state safely, and produce accurate results based on Event Time. Rather than simply explaining theory, it allows you to experience how real-time stream processing systems are designed and operated through actual source code and architectures. For those who have found real-time processing vague or wondered what lies beyond messaging, this course will provide a clear direction.

This course explores microservice architecture and distributed environments not as a simple list of technologies, but from the “design perspective” required in real-world practice and technical interviews. Starting with the differences between monolithic architectures and MSA, it systematically covers gradual migration strategies, modular monoliths, clean architecture, and hexagonal architecture, clearly explaining why each choice is necessary and the trade-offs that come with it. Through hands-on exercises, you can directly verify the intentions behind each structure and learn about the core challenges 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 do more than impart knowledge: it seeks to elevate your way of thinking about distributed systems to the next level.

Learn the process of building essential observability in a microservices architecture (MSA) environment, from the basics to hands-on practice. Through step-by-step exercises, you will learn standardized data collection using OpenTelemetry, trace storage and search with Grafana Tempo, and visualization using TraceQL. You will also learn how to trace service flows through distributed tracing, identify bottlenecks, and analyze the causes of failures.

Learn how to build data pipelines with Apache Airflow, from the basics to real-world applications. Understand Airflow’s core concepts and architecture, and practice advanced design patterns frequently used in the field, including dynamic DAGs, parallel processing, distributed processing, and Custom Operators. Set up a hands-on environment with Python and Docker, design and operate real-world workflows, and develop practical skills for production use.

A Redis course created with a current Kakao interviewer. From hands-on practice with data structures ranging from String to Sorted Set to Sentinel and cluster configuration, you’ll build design rationale that holds up in interviews and real-world work.

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.

As you work in backend development, you eventually find yourself facing a certain concern. As services multiply and traffic increases, there comes a point when simple REST communication and a CRUD-only structure begin to show their limitations. I experienced the same problem in practice and went through many trials and errors trying to balance performance with structural complexity. The solution I chose in that process was NATS. Its simple, single-binary-based setup, ultra-low-latency performance measured in microseconds, and practical feature set—from Pub/Sub and Queue Groups to JetStream—made it a highly realistic choice for actual service environments. This course is not about listing NATS’s features. Based on the problems I encountered in practice, it explains through code and workflows when and why I chose NATS and how I designed the architecture. From those new to messaging systems, to backend developers preparing for employment, and senior developers considering better architectures, this course will help everyone understand distributed systems and grow to the next level.

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

Systematically learn the distributed NoSQL database Cassandra, from basic concepts to practical application. Develop high-volume data processing capabilities through practice-oriented theory and hands-on exercises, including data modeling, query optimization, and cluster configuration. Even without prior database experience, you can grow into a Cassandra expert based on the know-how of a current Silicon Valley developer.

The biggest challenges when operating a batch system that processes millions of records are performance degradation and the difficulty of recovery when failures occur. Simple loops or poor design cannot solve these problems. In this course, based on experience handling large volumes of data reliably in real-world service environments, you will learn the architecture and operating principles of Spring Batch, along with design methods that achieve both performance and stability. Going beyond a simple explanation of its features, this course helps you develop fundamental problem-solving skills for data processing through practical batch architectures that can be applied directly in the workplace.

When you find yourself constantly updating Swagger documentation, aligning API specs, and repeatedly communicating with the frontend, you start to wonder, "Why am I doing the same thing twice?" I also felt similar frustrations in my professional experience, which led me to use GraphQL extensively and develop an interest in data-centric design. This course goes beyond simple GraphQL syntax; it explores the real-world problems it was created to solve, along with practical considerations like Resolver structures, the N+1 problem, and Federation. I've structured this course to help you naturally learn how to reduce communication costs between developers and design more flexible API structures.

This course covers RPC communication techniques for maximizing performance in large-scale MSA (Microservice Architecture) environments. Going beyond simple gRPC practice, you will learn how to implement stable and efficient service-to-service communication in real-world production environments where hundreds of microservices operate simultaneously. Based on Golang, the course takes a practical, hands-on approach to writing Protocol Buffers (proto) syntax, generating code automatically and implementing services, understanding gRPC’s architecture and advantages over traditional RPC, and applying performance optimization strategies. To ensure that even non-majors and beginners in server development can easily follow along, it explains everything step by step—from the concept of RPC to gRPC’s internal operating principles—helping you develop practical skills that can be applied directly to real-world services.

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.