What I build
Custom software, designed and shipped by one senior engineer.
Backend systems, internal portals, product MVPs, systems that finally talk to each other, and the AI development infrastructure a team needs to work on its own codebase. One engineer, end to end.
01 Capabilities 5 build categories
What I get asked to build
Different shapes, one engineer and one bar. Where a category has a case study, it is linked rather than retold.
-
01
Backend & APIs
The system behind the screen: the data model, the business rules and the interfaces other software talks to. Built to be read and changed a year from now, not just to pass a demo.
Example work
- REST and GraphQL APIs for a web or mobile front end
- Domain logic that currently lives in spreadsheets and people's heads
- Background processing: scheduled work, queues, retries that actually retry
- Replacing a fragile service that nobody wants to touch
-
02
Portals & Dashboards
Interfaces for the people who run the business — staff, partners and customers — showing real state from the real system instead of a report someone exports on Fridays.
Example work
- Customer or partner self-service portals
- Internal admin and operations consoles
- Live operational dashboards over your own data
- Role-aware access so each person sees only their slice
-
03
SaaS MVPs
A first real version of a product idea: narrow on purpose, deployed, instrumented and usable by actual customers — built so the second version is an extension rather than a rewrite.
Example work
- A founder's idea taken from sketch to a running, hosted product
- The foundations a paid product needs: accounts, billing, and each customer's data kept from the next
- A new line of business carved out of an existing system
- Something you can put in front of design partners and learn from
-
04
Systems Integrations
Getting systems that were never designed to cooperate to agree on the facts — with the failure cases handled, because integrations fail in production and pretending otherwise is how data goes wrong.
Example work
- Connecting a system of record to the tools your team actually uses
- Third-party and vendor APIs, including the badly documented ones
- Data migrations and reconciliation between two sources of truth
- Webhooks, sync jobs and the retry and alerting around them
Read the case study: Production E-Commerce and Savings Platform
-
05
AI Coding Infrastructure
Setting up a project-specific agentic coding harness for your team's codebase: specialized agents with separated responsibilities — business analyst, architect, engineer, QA, reviewer and an orchestrator that routes work between them — plus project skills, code-review skills and stack pattern libraries generated from the conventions already proven in your code. Stack-agnostic, and it works in both directions: bootstrapping a new project that has no conventions yet, or retrofitting an existing hand-written one where the conventions have to be read out of the code.
Example work
- Retrofitting a harness onto a large existing codebase people already depend on
- Bootstrapping one for a new project before its conventions harden
- Specialized agents whose responsibilities are separated, so the identity that writes a change is never the one that signs it off
- Deterministic, resumable quality gates that stop where they failed
- Skill and pattern libraries derived from your codebase, not an internet average
Read the case study: Project-Specific Agentic Coding Harness
02 Stack 10 technologies
The stacks this is built on
Elixir and Phoenix by default: a deliberate, boring-on-purpose toolchain for systems that have to stay up and stay changeable, and the one this site runs on. TypeScript, React and Next.js on a Node API when the product or your team calls for it — in production for a client today.
- Elixir
- A functional language built for systems that keep running while parts of them fail.
- Phoenix
- The web framework: fast by default, with a clear boundary between web and domain.
- LiveView
- Real-time interfaces rendered on the server, without a second front-end codebase.
- PostgreSQL
- The system of record. Constraints in the database, not just in the application.
- Oban
- Durable background jobs — scheduled work and retries that survive a restart.
- TypeScript
- Typed end to end: the API, the web app and the schema shared between them.
- Node.js and Fastify
- Schema-validated APIs where the product or the team is JavaScript already.
- React and Next.js
- A separate client-side front end, where the product calls for one.
- Drizzle ORM
- Typed SQL over PostgreSQL, with the migrations kept in the repository.
- Google Cloud
- BigQuery for analytics at scale and Cloud Storage for files, on the client's own account.
And when you have a strong preference for a stack, I build in yours — the engineering habits travel, the language is a detail.
03 Process 4 steps
How an engagement runs
Four steps, and the first one is a conversation. Scope is established in discovery — there is nothing to choose from before it, and nothing is quoted without it.
-
01
Discovery
A focused conversation with the AI discovery system on this site. It works through the problem, the constraints, the systems already in play and what success actually looks like. This is where scope comes from.
-
02
Proposal
A written proposal built from that conversation: the scope as I understood it, the architecture, the milestones and how we will both know it works. If I have read the problem wrong, this is where you find out cheaply.
-
03
Build
Iterative delivery behind a real quality gate — tests, review and a working system you can watch move every week. You talk to the engineer writing the code, because there is no one else in the chain.
-
04
Launch
Deployed, monitored, documented and handed over — or kept running by me if you would rather not own the operations.
Every engagement starts in the discovery chat. It is the only way scope gets established, and it costs you a conversation.
04 Proof
Proof, not adjectives
Each category above points at software that exists and runs. The full portfolio is the argument.
Client engagements are published anonymized. The AI coding infrastructure above was delivered as a paid engagement against a production codebase at a national performance-marketing company.
See the full portfolioKnow what you need built?
Bring the problem, not a specification. The discovery chat works out the scope before anything else happens.