Posts

My father wrote a poem in Korean and called it 참회(懺悔), ‘Repentance.’ The full poem, followed by my short response.

A mid-project retrospective on a personal automated trading platform built with Rust + Python + React. With ETF rebalancing and single-stock signal trading both in place, a record of how the safety layers — halt, block, detect, simulate — got built before going live.

The structure of walk-forward analysis, the metrics it produces (IS-OOS gap, parameter stability), a momentum-lookback tuning case, and the limits that keep it from being a universal validator.

The core constraints of the four Korean retail account types — general, ISA, pension savings, and IRP — covering tax-free thresholds, tax deductions, the 70% risk-asset cap, and access to direct foreign investment, plus a strategy-to-account mapping.

Concrete cases of look-ahead bias and survivorship bias — full-period momentum normalization, financial disclosure lag, close-on-close fills, S&P 500 reconstitution, the limits of free APIs — followed by an avoidance checklist.

Covers Markowitz’s mean-variance model as the mathematical foundation for setting asset weights, the two optimal points on the efficient frontier (Min-Variance and Tangency), and the practical adjustments that compensate for the model’s weaknesses.

MSA is a decision about which criterion to use to decompose the system. Domain boundary, data ownership, scale pattern, failure isolation — the chosen criterion creates the service boundaries, and those boundaries decide communication and data in turn.

ES and CQRS address how a system’s source of truth is shaped and how its views are separated from it. Adoption cost spreads across the system, so I lean toward adopting only when the value can be stated explicitly.

Distributed transactions are about how a single ACID transaction decomposes across services and how its pieces are reassembled. The roles and trade-offs of 2PC, Saga (Choreography vs Orchestration), and Outbox.

settings.json, CLAUDE.md, slash commands, subagents, hooks. Claude Code’s customization surface settles into four layers once you pick one axis: when does each one step in?

alacritty + tmux + nvim + zsh + Claude Code in a single screen. The choices and structure behind a terminal-centric development environment.

A good engineer isn’t someone who knows technology well, but someone who can share that knowledge with their team.

A retrospective on column-level encryption of sensitive data in a running service. Envelope encryption, DEK granularity decisions, the WHERE clause constraint that led to HMAC, and the migration automation Skill that spread the work across the org.

A retrospective on the internal hackathon. How an idea I proposed evolved with the team into a 1st-place project and an internal launch — and the starting point for using AI tools in earnest.

Looking at JIRA’s issues and workflows as a graph of work units — covering the Sprint lifecycle, issue hierarchy, Git/GitHub integration patterns, and automation flows.

GitHub Actions seen as an event-driven automation engine — the three-layer abstraction of workflow / job / step, plus the operational details of triggers, runners, and secrets.

Looking at GitHub PRs as a collaboration layer on top of Git’s change graph, and walking through the Code Review cycle, PR-level design, and merge strategies.

Looking at Git as a graph of changes — and seeing how commit hygiene, branching strategy, and the merge-vs-rebase choice are all decisions about the shape of that graph.

How Security Groups (stateful, per-instance) and NACLs (stateless, per-subnet) form different layers of defense in a VPC, plus the common pitfalls each surface.

Comparing the four mechanisms that connect a VPC to other VPCs, on-premises networks, and external services — Peering, Transit Gateway, Site-to-Site VPN, and PrivateLink — across topology and cost.

Retrospective on building a system that automatically identifies low-performing SSP inventory and throttles traffic to improve contribution margin. Covers the evolution from Imp Cost Ratio to a predicted contribution margin rate approach.

How Route Tables decide traffic paths inside a VPC, the role of Internet Gateway and NAT Gateway as external exits, and the actual meaning of Public/Private Subnet.

How VPC simulates a private network boundary by combining IP CIDR, Subnet, and Tenancy. Includes vendor naming map across AWS / GCP / Azure / Alibaba.

Covers technical indicators (RSI, SMA Cross, MACD, Bollinger Bands) for reading price movements, composite signal design, and a comparison of three strategy types across different time horizons.

Covers factor scoring methods (Z-Score, Rank) for combining indicators into a single score, plus the basics of rebalancing and asset allocation.

Covers the formulas and interpretation of CAGR, MDD, Sharpe Ratio, and other backtest metrics, plus five common backtesting pitfalls.

Covers the role of price momentum and dividend yield as factors in quant investing.

Covers how to judge whether a company is cheap (valuation) and whether it earns well (quality) — formulas and interpretation of PER, PBR, PSR, ROE, ROA, and debt ratio.

Covers OHLCV data as the starting point of quant investing, the difference between simple and log returns, and the meaning of market capitalization.

A three-step pattern combining dual write and fallback read to transition data formats in live services without downtime.

How the CMK/DEK two-tier key structure in envelope encryption limits key leak impact and simplifies key rotation.

Building my first ML Lifecycle — a three-tier architecture for an ad Fallback CTR prediction — as a backend engineer without an AI background. The technical decisions I made, and what I learned through running it.

Which slot of the ML lifecycle each MLflow component fills, and which pieces a lightweight team can pick.

A Circuit Breaker’s trip trigger and recovery strategy must be designed together. Trip without recovery cuts the dependency permanently; recovery without a trip basis becomes meaningless cycling.

Before choosing a rate limit algorithm, the protection layer decides which algorithms are even available. This post lays out how L4/L7/Application layers and Token/Leaky/Sliding/Fixed algorithms intersect.

An external event drove ad traffic far above normal, triggering a cascading failure. The real problem was that the filtering component was a single point of failure — and the fallback sat on top of it too, so one collapse pulled both down at once. The fix took three paths: removing the fallback’s dependency (independence), adding rate limiting to the component itself (protection), and reconsidering the runtime (throughput).

sklearn and ONNX aren’t competing at the same layer. Once you separate their roles, the real question becomes ‘do I need an ONNX layer at all?’

The structure and characteristics of Logistic Regression, and why an old model still serves as the baseline in CTR prediction.

The deploy was two days old, and the metrics had been calm the whole time. The moment we turned off the cache refresh batch, ad serving stopped. A retrospective on the missing verification of what a deploy actually changed.

Container orchestration basics and what backend developers need to know: core objects, networking, scaling with HPA, and operational essentials.

Go’s concurrency model builds on CSP, providing Goroutines and Channels as core tools. An overview of how each works and when to choose what.

A record of implementing and benchmarking three Go concurrency patterns — mutex, channel, and lock-free — to build hands-on understanding.

Why MongoDB and Redis end up in different roles even under the same NoSQL umbrella. A comparison across data model, storage, schema, scaling, and use cases.

A record of designing and building a chat system as a personal project to gain hands-on experience with Kafka and Hexagonal Architecture.

Spring MVC assigns one thread per request. When I/O waits pile up, threads sit idle. WebFlux replaces this with an event loop-based non-blocking model. A summary of the structural differences from MVC, the Reactor pattern, and when to choose which.

HTTP/1.1 processes requests and responses sequentially. HTTP/2 changed this with multiplexing, binary framing, and header compression. A summary of the differences between the two protocols and gRPC, which runs on top of HTTP/2.

Covers container concepts, the differences from VMs, Docker’s architecture, and the basics of Dockerfile and Docker Compose.

The difference between splitting code by technical layers (horizontal) and by features or domains (vertical). Trade-offs and selection criteria for each approach.

Designing a Nest.js-based fallback server while removing a legacy ad server. Why a horizontal layered architecture fit better than Nest.js’s default vertical module slicing for a single API with complex business logic.

Nest.js provides a DI container and Module system at the framework level in the Node.js ecosystem. A summary of its core design principles: IoC, DI, Module, and Provider.

Layered architecture separates code into horizontal layers by technical responsibility. A summary of the four-layer structure, dependency direction rules, and how DIP decouples layers.

Core Kafka concepts (topics, partitions, consumer groups, replication) and the background behind KRaft mode, which removes the ZooKeeper dependency.

Core concepts of Hexagonal Architecture and its idiomatic implementation in Go using implicit interfaces and package structure for dependency direction control.

Builder is the answer when three limits of constructors meet at once — many parameters, some optional, and step-wise validation. With fewer than all three, simpler tools suffice. When the language provides rich named/default parameters, the need for Builder shrinks as well.

Factory’s shared intent is separating creation from use. The three variants — Factory Method, Abstract Factory, and Static Factory Method — split creation differently and suit different conditions. Static Factory Method is the variant most often encountered in practice, and DI containers absorb part of Factory’s explicit role.

Singleton is one of the simplest patterns but the canonical anti-pattern debate. The decision to bundle single-instance guarantee with global access into one pattern causes tight coupling and test difficulty. DI is the general alternative that separates the two intents.

DIP (principle), IoC (pattern), and DI (technique) sit at different levels of abstraction. The hierarchy must be clear before framework features and design principles can be told apart.

A pattern for switching from full cache refresh to incremental refresh. Separating data by update frequency and applying change detection reduces network costs.

How I reduced network costs and enabled instance downscaling by switching from full cache refresh to incremental refresh for campaign configuration data.

What each of the four ACID properties actually guarantees in an RDB transaction. A/C/D are relatively clear guarantees, but only I has ’levels’ — the gateway to the correctness vs. concurrency trade-off.

A retrospective on moving ad budget pacing from a fixed-rule scheme to a two-layer control loop — per-campaign learning sets the baseline, real-time correction absorbs drift.

A record of implementing the multithreaded HTTP server from Rust Book Chapter 20, experiencing how ownership and concurrency safety are enforced at the type level.

Two transport protocols that backend developers encounter constantly. A summary of TCP and UDP — connection establishment, reliability guarantees, flow/congestion control mechanisms, and selection criteria.

SwapDo, a deepfake-based face synthesis meme service. A record of five months as a developer and team lead in a startup team.

HTTP is stateless. Maintaining user authentication requires storing state somewhere. This post covers the structure, trade-offs, and storage strategies of server-side sessions and client-side JWT tokens.

A startup born from a casual League of Legends habit. From architecture design to desktop apps, a record of two people building a service that grew to 10,000 users over five months.

Entering the GDG Korea Android 11 Hackathon solo, building both server and app in three weeks.

Korea Railroad Industry Information Center’s public-data hackathon. A three-person team built an Android app that surfaces hidden rest spaces inside subway stations, over three weeks.