Multi-agent systems in production: what CrewAI handles and what you have to build yourself
What CrewAI gave us in production, what it did not, and the real lessons from running a hierarchical multi-agent trip-planning system with real users.
Archive
Blog
Notes on architecture, internal tooling, mobile apps, product systems, AI infrastructure, and engineering leadership.
13 years of building: what I'd tell a junior developer today
What turned out to matter across 13 years of building systems, tools, products, and teams, and what I would focus on if I were starting again.
Building Bloat: a macOS developer runtime manager with Go and Tauri
Why we started building Bloat, why Docker stopped fitting our local workflow, and how the daemon, desktop app, DNS, TLS, and signed runtime manifests came together.
The Drift: How Engineering Leaders Lose Touch with Code (and How I Fight It While Managing 20 Engineers)
What staying technical actually looks like while managing a 20-person team, and the tradeoffs required to keep judgment grounded in real engineering work.
Fine-tuning a support model end to end: from SQL dump to LoRA adapter
A practical walkthrough of turning support chat SQL dumps into a fine-tuned LoRA adapter, including extraction, canonicalization, shard processing, and training decisions.
DSPy for production: solving LLM output consistency without prompt engineering
How DSPy helped fix score collapse in Sherpa when smaller self-hosted LLMs kept returning safe middle-range values instead of real differentiation.
Self-hosting first: why we replaced Pusher, Sentry, Algolia, and S3
Why I increasingly prefer self-hosting when the protocol is open, the service is understandable, and ownership buys real control without forcing client rewrites.
Building an MCP server into Vortex: what it means to make your app tool-accessible
What it meant to add MCP tools to Vortex, the Laravel MCP package, how tools are structured, what good tool design actually requires, and what changed when an AI could operate the release workflow directly.
CQRS in a Laravel + GraphQL stack: what we split and why
Why plato-next splits reads and writes across GraphQL Yoga + Laravel, what each side owns, how the Prisma schema bridges them, and where the complexity is actually worth it.
Prisma as the single source of truth: generating GraphQL types, Zod schemas, and Eloquent models from one schema
How we structured Prisma in plato-next to drive code generation across five outputs, TypeScript client, Pothos GraphQL types, Zod validation, Eloquent models, and test data, and what that buys a polyglot stack.
Designing @plato/rn-chat as a reusable React Native SDK
What changed when chat became a reusable React Native library instead of app-specific code, the API design decisions, the imperative ref pattern, Sockudo integration, and what self-hosting as an SDK forces you to think about.
Self-hosting Sockudo: dropping Pusher with zero per-message cost
The full story of replacing Pusher with Sockudo, why protocol compatibility made this migration a config change, and what a year of running your own WebSocket server actually looks like.
Why we moved from Stitches to Tailwind, and what we kept
What the migration from Stitches-based Atom to Tailwind taught me about where the stable layer in a design system actually lives, and why Radix UI survived the whole transition untouched.
Module-scoped Jotai atoms: how we manage state across 30+ pages in Plato
Why module-scoped Jotai atoms worked better for Plato than one large global store, and how the boundaries held up as the app grew to 30+ pages.
Staying technical as an engineering manager: what I'm still figuring out
Three months into engineering management, writing this to understand what staying technical actually means when the calendar suddenly has eight hours of meetings in it.
Building a design system from scratch in 2022
Why we built Atom instead of adopting a large UI library, how the package layers worked, and what I learned from making that architectural bet.
What I set up first when bootstrapping a React Native app
The order I follow when bootstrapping a production React Native app, and why the sequence matters more than the exact library choices.
AOP in PHP: what aspect-me does and why I built it
What aspect-oriented programming means in plain terms, why method interception is useful in PHP, and how aspect-me fits into that problem.
PHP 8: the features I actually use
The PHP 8 features that changed my day-to-day code most, and the ones I still find less relevant in ordinary web applications.
Code review at scale: what I learned running it for three years
How my view of code review changed after years of leading reviews across a multi-brand platform and using review as a teaching tool instead of a gate.
From developer to lead: the first six months
What surprised me in my first six months as a lead, especially around communication, reviews, and the shift from shipping code to enabling a team.
EAV in Laravel: what I built and why
Why I built an EAV package for Laravel, what Magento taught me about the pattern, and how I wanted the API to feel cleaner in Eloquent.
Subtree splits: publishing parts of your monorepo as separate packages
Why I used subtree splits for mods-framework packages, how the workflow works, and when the extra maintenance is worth it.
Building a modular application framework on top of Laravel
A technical look at how I structured mods as a modular application framework on top of Laravel, including discovery, theming, and package splitting.
Upgrade-safe extension points in Laravel
Why framework extension points break so easily, and how I started thinking about safer ways to extend behavior with layout-core and aspect-me.
Why I started building my own PHP framework
Why I started the mods-framework experiment: not to replace Laravel, but to make modular application architecture a first-class idea.
Moving from agency work to enterprise consulting: what actually changes
What changed for me moving from agency delivery at BORN Group to long-term enterprise consulting work at Cognizant.
Building mapemall.com: Magento for a 500-brand Indonesian retailer
What changed when Magento had to support the catalog complexity of a 500-brand retailer like Mapemall.
Inheriting a Magento codebase vs building from scratch: an honest comparison
What I learned from working with both clean and tangled Magento codebases, and how I decide whether a system is worth saving.
Multi-currency, multi-region: building Magento for the Middle East
What I learned building Magento stores across UAE and Indonesia: multi-region commerce is much more than translation and exchange rates.
Magento performance in production: lessons from Xcite.com
What I learned about Magento performance once Xcite.com traffic made development-time assumptions stop working.
EAV in Magento: why it exists, when it hurts you, and what I built to fix it
After spending enough time inside Magento's catalog model, I finally started understanding why EAV exists, where it helps, and where the tradeoff starts getting expensive.
Database design for a social network: decisions I made on tripzar.com
The database decisions I made while building tripzar.com, especially around social relationships, feeds, and linking traveler content to places and trips.
Designing a hotel reservation API from scratch
What I learned while designing a hotel reservation API for ofertadeldia.com, especially around availability, reservation states, and the parts I got wrong the first time.
Building your first Magento module: what I wish I knew
The Magento 1 module concepts that confused me most when I started building extensions at Contus, and the mental model that finally made them click.