DAEMON Core
Core architectural preferences: modular monoliths, vertical slices, and why Django still fits my way of building.
Start here: Python Philosophy and Django Philosophy — Why I Still Choose This PairBlog
Architecture decisions, deployment war stories, and technical notes across both English and Korean posts.
Series
Posts are grouped by recurring themes so the blog reads more like a set of connected essays than a flat archive.
DAEMON Backend
Backend contracts, PostgreSQL-first decisions, lifecycle rules, domain boundaries, and pragmatic performance choices.
Start here: Django DRF vs Django Ninja vs FastAPI — What I Choose and WhenDAEMON UI
Server-centered frontend work with HTMX and Alpine, without defaulting to SPA complexity.
Start here: Why I Chose HTML, CSS, and HTMX Over React for DjangoAI Contracts
Why I trust schemas more than fluent model output, and how Pydantic and PydanticAI keep AI systems structured.
Start here: Pydantic Is Not Just a Validator. It Is a Contract.Deployment Patterns
Release flow, image build discipline, and deployment structures that keep operations calm.
Start here: Justfile vs Docker — They Are Not AlternativesTooling
Project command surfaces, Python packaging defaults, and tool choices that shape daily development speed.
Start here: uv vs pip — Why pip Is No Longer My DefaultSportsIQ
Sports-domain AI architecture notes around pose estimation, biomechanics, and product direction.
Start here: SportsIQ Architecture — Sports Science Meets Pose EstimationDAEMON Core
- Python Philosophy and Django Philosophy — Why I Still Choose This Pair Python and Django share a practical philosophy centered on readability, explicitness, and useful defaults. That still matters in product work. 2026-03-17
- Modular Monolith vs Microservice — Why I Start with the Monolith Microservices can look scalable, but in early products they often import operational complexity before the product earns it. 2026-03-15
- Why I Prefer Vertical Slice Architecture Vertical Slice is not folder aesthetics. It is a structural choice for cohesion, localized change, and more controllable AI-assisted development. 2026-03-16
DAEMON Backend
- Django DRF vs Django Ninja vs FastAPI — What I Choose and When DRF, Django Ninja, and FastAPI each solve different problems. I choose between them based on product friction, not hype. 2026-03-18
- Why I Choose Django + Pydantic + HTMX Over FastAPI FastAPI is not a bad tool. But when I optimize for full product flow, admin surfaces, server rendering, and architectural cohesion, Django + Pydantic + HTMX fits better. 2026-03-22
- Why I Removed Redis and Kept Just PostgreSQL Below a certain scale, Redis often adds more operational complexity than real value. For many products, PostgreSQL plus pgmq is enough. 2026-03-19
- PostgreSQL-First Architecture: You Can Go Far Without Redis Instead of starting with multiple data stores, I prefer going deep on PostgreSQL first. In many products that creates a stronger balance between development speed and operational calm. 2026-03-23
- Why I Choose django-lifecycle Over Django Signals Signals look convenient, but they often make business rules harder to see. In state-heavy systems, django-lifecycle has been easier for me to read and control. 2026-03-23
- Django Domain Boundaries: Why I Force an interface.py If cross-domain imports remain unrestricted, a modular monolith degrades quickly. I use interface.py to keep Django boundaries intentional. 2026-03-24
- Why I Pull JSON-LD into Backend Contracts Too If you see JSON-LD only as an SEO script tag format, you are only seeing half of it. I use its semantic framing to make backend contracts less ambiguous. 2026-03-24
- Rust Performance Without Rust Maintenance: granian, orjson, and Pydantic v2 I do not always need to write Rust directly. In many cases I can capture a lot of the performance upside by leaning on strong Rust-backed Python components. 2026-03-24
DAEMON UI
- Why I Chose HTML, CSS, and HTMX Over React for Django I did not avoid React out of ignorance or dislike. In the architecture I chose around Django, modular monoliths, and vertical slices, HTMX felt more natural. 2026-03-21
- Modern UI Without React: HTMX + Alpine A modern UI does not automatically require an SPA. With HTMX and Alpine.js, I can keep a server-centered architecture and still deliver strong interaction. 2026-03-24
AI Contracts
- Pydantic Is Not Just a Validator. It Is a Contract. I do not use Pydantic only to validate user input. I use it to lock contracts across requests, domain boundaries, and AI outputs. 2026-03-24
- AI-Era Backend Design: Why I Trust Schemas More Than Natural Language The smarter LLMs become, the more important schemas get. Natural language is flexible, but system boundaries need explicit structure. 2026-03-24
- With PydanticAI, the Real Priority Is the Result Schema, Not the Model Model choice matters in multi-agent systems, but result schema matters more for stability. I trust explicit output contracts more than model charisma. 2026-03-24
Deployment Patterns
- Justfile vs Docker — They Are Not Alternatives Justfile and Docker live at different layers. One defines command workflows, the other defines execution environments. 2026-03-12
- Build Offloading and GHCR — Why I Let CI Build Instead of My Laptop If container builds live only on a developer machine, reproducibility and deployment traceability suffer. CI plus GHCR gives a cleaner release path. 2026-03-14
Tooling
- uv vs pip — Why pip Is No Longer My Default pip installs packages, but uv manages more of the project lifecycle with better speed and ergonomics. My default has shifted. 2026-03-10
- pyproject.toml vs requirements.txt — Declaration Is Not the Same as Installation A pyproject.toml describes the project itself. A requirements.txt usually describes an install target. Treating them as the same causes confusion. 2026-03-11
- Justfile — Why I Define Standard Project Commands Explicitly A Justfile is more than a shortcut list. It becomes the command interface that tells people and tools how the project should be run. 2026-03-13