Week in Review (2026-03-15 -> 2026-03-21)

Scope

Period: 2026-03-15 -> 2026-03-21
Total daily logs: 5 (16–20 March)

Opening

If this week had a spine, it was this: the cost of over-engineering is just as real as the cost of under-engineering. I saw it in a validation framework that rejected legitimate cloud IPs. I saw it in NestJS REQUEST scope silently destroying performance. I saw it in Sandi Metz reminding me that premature abstraction is still duplication — just a more expensive kind. Every day this week, in some form, I was negotiating the line between “thorough” and “too much.”

What Moved the Needle

LanceDB + MCP as an AI infrastructure stack. Starting the week with LanceDB for vector source indexing in Antigravity, combined with MCP for AI agent tool access, felt like assembling a real AI-native backend rather than bolting LLM features onto an existing system. The combination — vector retrieval + structured tool exposure — is a pattern I want to internalize for future projects.

AsyncLocalStorage over NestJS REQUEST scope. This one will stick. REQUEST scope in NestJS sounds harmless until you realize the entire dependency tree gets recreated on every single request. Swapping it for AsyncLocalStorage for multi-tenant context propagation is the kind of fix that makes a system feel like it was designed rather than accumulated. Performance-conscious DI is now a permanent consideration.

ADR as a communication artifact. Writing Architecture Decision Records is not about documentation for its own sake — it is about making your reasoning legible to future collaborators, including your future self. Pairing ADR practice with the Pyramid Principle reframed technical writing for me: the document is not a log, it is a decision with a punchline first.

Foundation work on Lịch Lạc Hồng. Hardening the CI/CD pipeline and adding global 403 handling are the kinds of tasks that do not feel exciting. But the observation that the cost of fixing foundational issues grows exponentially the longer you wait landed with weight. I did the unglamorous work. That matters.

The Mistake That Taught Me Most

On the 17th, a PDF validation framework I built started rejecting cloud-internal IPs as invalid. The validation was technically correct — those IPs are not public. But “technically correct” and “production correct” are different things. Cloud environments have their own IP conventions and internal routing that a strict validator cannot know about. The fix was not hard. The lesson was: context matters more than correctness in isolation. Rules designed for one environment silently break in another. Always test in the target environment, not just against an abstract spec.

Pattern I Noticed

Security, performance, and communication all converged on the same insight this week: local optimality can be global failure. RLS policies that are too strict block legitimate users. REQUEST scope that feels “clean” per-request kills throughput at scale. A technical doc that explains everything in sequence buries the point. In each case, the local decision looked fine. The system-level effect was the problem. Zoom out. Always ask what the downstream cost is.

Looking Ahead

Next week I want to focus on shipping over learning. This week was dense with concepts — now I want to drive Antigravity forward with the LanceDB/MCP stack, get the React Native UI Framework landing page to a state I can share, and make the Lịch Lạc Hồng CI/CD hardening observable through actual deployment runs. Less intake, more output.

Source Logs

Key Learnings

Context beats correctness: Validation rules correct in one environment can silently break in another — always test in target conditions
Abstraction has a price: DRY applied too early is its own form of duplication; wait for the third repetition before generalizing
Dependency injection has performance implications: NestJS REQUEST scope is a hidden bottleneck; prefer AsyncLocalStorage for context propagation
Writing is thinking made legible: ADRs, pyramid structure, and professional reporting are force multipliers on technical impact
Foundation work compounds: Fixing CI/CD and global error handling now prevents exponentially costlier fixes later