Twenty years shipping mission-critical software — and the accountability of the person who did the work.
Every seat at the table.
Senior full-stack architecture, production AI systems, and twenty years of judgment about what to build, what to cut, and what to keep.
I've been writing software professionally for twenty years. In that time I've held most of the seats at the table — CEO of my own companies, CTO, VP of Product, software architect, lead engineer, and most recently head of AI engineering. I know what each of those jobs actually requires because I've done them.
The work has spanned most of what commercial software actually does — consumer platforms and operational systems, mobile and desktop, content and commerce, data pipelines and infrastructure. The common thread: real users, real scale, working on day one. More recently, multi-agent AI systems, RAG pipelines, and the orchestration layer that makes those do real work in production instead of demoware.
What interests me now is software with real operational consequences — the kind where naming the actual problem matters as much as building the solution.
The firm scales to the work.
Streamline is sized to the engagement. A senior lead, on-call operations, a production team of AI agents, and additional senior hands pulled in exactly when a project calls for them.
The lead. I lead every engagement directly — planning, architecture, code, and deployment. Over twenty years I've played every role on a software team, which means the planning conversation, the architectural decision, and the commit message all come from the same person. The person who sold you the work is the person writing it.
Operations. Contracts, invoicing, project logistics, and the administrative work any real firm needs — run by my wife, our VP of Operations, on an as-needed basis. Operations scale to the engagement, not to the calendar.
The brain and the hands. Twenty years of engineering judgment and a designer's eye decide what gets built — architecture, the call about what to cut, the polish that separates considered from assembled. AI handles the typing, and it types faster than I can speak. The output keeps pace with the thinking.
A senior network, pulled when the work requires it. When an engagement calls for an additional senior hand — a specialist in a domain, a second pair of eyes on a high-risk migration — we pull from a small network of senior engineers I've worked with for years. Named people, not a contractor pool. When the engagement doesn't call for them, they're not on the payroll.
Whatever the task or project demands is what gets done. The firm stays right-sized for the work — you're paying for the work, not for the overhead.
What happens if I get hit by a bus.
It's a fair question, and it's the right one to ask a small firm — the question bigger firms dress up rather than answer.
I'd ask it too. Here's what you're actually buying, and what you keep if I'm out.
Code ships against paid milestones. Source, documentation, credentials, and deployment — released to your servers as each milestone is paid, not at the end of the engagement as a handoff. No firm stands between you and the software. If something happens to me tomorrow, you're inconvenienced. You already have everything paid for and delivered, ready for the next senior engineer to pick up.
Documentation ships as a deliverable. Every engagement produces architectural docs, runbooks, and deployment guides a senior engineer you've never met could read in a week and continue from. Small firms survive on documentation — it's the continuity layer. A team of seven can tolerate bad docs because the lead remembers everything. I can't afford to.
The codebase is legible by design. Working with AI agents end-to-end means the code ships with high test coverage, clear type annotations, and inline context as defaults. Not because I insist on it — because it's the way the work gets done. A new engineer reading it doesn't need me translating.
A named continuity network. If another senior hand is needed on an engagement, it's a specific person I've worked with for years. If something happens to me mid-engagement, the relationship transfers to a named person I trust — not a contractor pool, not a PDF with a phone number on it.
The seven-head firm has its own bus factor — just hidden. The senior engineer who understood your system leaves for a competitor. Your account manager rotates. The offshore team gets reassigned to someone else's account. Continuity at a larger firm isn't better; it's buried under more layers, and you only see the cracks the day you need it to hold.
The difference is where the risk lives. With a boutique firm, it's named, visible, and addressed up front. Milestone-based code release, documentation, a named continuity network — what's been paid for is on your servers, in writing, by design.
What you can hold us to.
The operational commitments behind every engagement. Printed on the proposal, enforced in practice.
We tell you the truth. Even when it costs us the engagement. If we're not the right fit, we'll say so and point you somewhere useful.
We ship. Progress shows up in the deployment, not in the weekly status call. No standing demos, no theater.
We write things down. Scope, milestones, price — on the page, before work begins. The proposal doesn't change unless you ask it to.
You own what you've paid for. Code released to your servers against each paid milestone. Source, documentation, credentials — yours as you go, not at the end. No vendor lock-in, no code held hostage.
Tell us what you're trying to solve.
If we're the right fit, we'll send a written proposal within a week. If we're not, we'll tell you and point you somewhere useful. Either way you'll hear back within 1–2 business days — usually sooner.