What I charge, and how the arrangement usually works. I'd rather you know before you email me.
Rates
$200 per hour — consulting on your project. Advisory work: architecture review, build-vs-buy decisions, second opinions on a plan or a vendor proposal, and technical direction. Short engagements where the deliverable is a decision you can act on.
$150 per hour — deep AI work. Model integration, extraction pipelines, prompt engineering and evaluation, multi-provider routing, and the traceability work that makes AI output defensible. The specialized end of what I do.
$100 per hour — base rate. Everything else: general software engineering, data pipelines, backend and frontend delivery, documentation, project management, and product work.
Minimum engagement: $5,000. Roughly 50 hours at base rate. Below that, the overhead of scoping and context-loading eats most of the value for both of us — I'd rather point you somewhere better than take a project too small to do well.
What I do
Twenty-five years in, the work isn't only writing code. I've been an architect, a development manager, a project manager, a team lead, and the person who wrote the documentation nobody else wanted to write. All of it is available:
- Engineering. Architecture through deployment — backend, data, frontend, AI integration.
- Technical documentation. Architecture docs, runbooks, API references, and the handover material that decides whether your team can actually own a system after it ships.
- Project management. Planning, sequencing, and running delivery on technical work — including Scrum, if that's how your team operates.
- Product management. Turning a rough idea into a specification that engineers can build and stakeholders can agree on.
- Fractional technical leadership. Architecture review, code review, and technical direction for teams without a senior engineer in-house.
Some of the most useful work I've done for clients was none of it code. If what you need is someone to figure out what should be built and write it down clearly, that's a legitimate engagement.
How engagements are structured
Hourly. For open-ended work, advisory, and anything where the scope will genuinely change as we learn. Billed against time tracked in Harvest, itemized per deliverable, invoiced monthly.
Fixed price. For well-defined projects with a clear endpoint. You get a number up front and it doesn't move unless the scope does. This requires a real spec — which is usually what discovery produces.
Monthly retainer. Roughly one day a week — about four days a month — from $3,200 per month at base rate, more if the work sits in the AI or advisory tiers. Suited to ongoing support, architecture review, code review, or acting as the senior engineer a team doesn't have in-house. Unused days don't roll over; the value is reserved availability, not a bucket of hours.
Equity or deferred payment. I'll consider a reduced cash rate in exchange for equity or revenue share on early-stage work. I've done it — Quokka was a company I co-founded rather than a client I billed. It has to be a product I believe in and a team I want to work with, and it generally works alongside some cash rather than instead of all of it. Ask if it's relevant to you.
What moves the number
Four things account for most of the variance between a cheap project and an expensive one:
- How clear the scope is. A written spec costs less to build than a conversation. If you don't have one, discovery produces it, and that's usually money well spent before committing to a build.
- How fast you need it. Compressed timelines cost more, because they mean reordering other commitments and accepting less margin for the unexpected.
- What's already there. Greenfield is cheaper than working inside an existing system, and a well-tested codebase is cheaper than one where every change carries unknown risk.
- Whether it has to withstand scrutiny. Audit trails, traceability, and regulated environments are real engineering, not a checkbox. If your output will be disputed or examined, that work has to be designed in from the start — and it costs more than a system nobody will question.
How it starts
A free call first. Tell me what you're working on and we'll talk it through. No charge, no obligation, and if it isn't a fit I'll say so and point you elsewhere.
Then paid discovery, usually. For anything substantial, the first engagement is a short scoped block — typically two to four weeks — that produces a concrete technical plan. You keep the plan whether or not you continue with me. It's the cheapest way for both of us to find out whether this works before anyone commits to a build.
The terms that don't change
- You own everything. Code, documentation, and infrastructure live in your repositories and your accounts from day one.
- Invoiced monthly, net 30, against tracked time.
- Estimates are estimates. If I think a project is going over, you hear it while there's still time to do something about it — not in the invoice.
How an engagement runs week to week — scope, weekly updates, issue tracking, handover — is described on the implementation page.
Questions
If your budget doesn't fit any of this, say so anyway. I'd rather have the conversation and tell you honestly whether the work is worth doing at the scale you can afford.