How a project actually runs.

The six phases

Every project I take on, regardless of size, follows this pipeline. Smaller projects compress phases. Larger projects extend them. None of them get skipped.

1. 01

   Free 30-minute discovery call

   Day 0 Free

   You describe the problem in plain language. I ask the questions that decide whether this is a project I can actually help with, or whether you need someone else.

   You bring

   • A rough description of what you want to fix or build.
   • Any existing system, screenshots, or spreadsheets if relevant.
   • A budget range, even if it is only "less than $50k" or "open".
   • A deadline if there is one, and why.

   I deliver

   • Honest read on whether this is a 2-week, 2-month, or 6-month project.
   • A short list of risks I can see from the call.
   • A go / no-go recommendation. If no-go, a referral where I can.

   Next: If both sides want to continue, I move to a fixed-price proposal within 3 business days.

2. 02

   Fixed-price written proposal

   3 business days Free

   A real document, not a spreadsheet quote. Every project I run starts here so we both know exactly what is and is not in scope before money moves.

   You bring

   • Any extra detail I asked for on the call.
   • Final clarity on must-haves vs nice-to-haves.
   • Names of stakeholders who need to sign off.

   I deliver

   • Scope: what is included, in writing.
   • Out of scope: what is explicitly not included, also in writing.
   • Milestones: 3 to 7 of them, each one demoable.
   • Total fixed price, with each milestone priced.
   • Payment schedule, GST, and payment terms.
   • Risk register: what could blow this up, and the mitigation for each.
   • Assumptions log: what I am taking as given. If any are wrong, scope or price changes.
   • Timeline: realistic dates, not aspirational ones.

   Next: You review. I revise once if needed at no charge. Then we both sign and the build begins.

3. 03

   Milestone-paid build

   Per project Per milestone

   Software built in slices. You see working software at every milestone, not a status report. If a milestone misses, you can stop and only pay for what was delivered.

   You bring

   • A single point of contact for decisions.
   • Access to the systems we are integrating with.
   • Timely review of each milestone (target: 3 business days).

   I deliver

   • Working software at every milestone, demoed live.
   • Source code in your repo, not mine. You own everything.
   • A short written summary at each milestone: what was built, what was deferred, what is next.
   • Invoice on milestone acceptance, due 7 days.
   • Weekly 15-minute check-ins so nothing surprises you.

   Next: Final milestone is "ready for UAT", not "ready to deploy". UAT is its own phase.

4. 04

   UAT with your real users

   1 to 3 weeks Included

   Not a checkbox. Real users in their real environment doing the work they actually do. This is where the issues that matter actually surface.

   You bring

   • A list of testers who represent your real users.
   • Time for those testers to actually use the software.
   • Honest feedback. Bugs are easier to fix in UAT than in production.

   I deliver

   • A test plan covering critical paths.
   • Triage of every issue: bug, scope change, or training need.
   • Bug fixes inside the original price.
   • A clear written estimate for any scope changes, signed off before I touch the code.
   • Re-test cycles until the critical-path issues are zero.

   Next: When you sign off UAT, we plan deployment. Not before.

5. 05

   Deployment plus 12 months free support

   Cutover day plus 12 months Included

   Production deploy with rollback drilled. The first year of support is included in the original price. Bugs are mine to fix. New features are scoped separately.

   You bring

   • A deployment window, ideally outside peak hours.
   • A rollback approver: the person who calls "abort" if something goes sideways.
   • A first-line support contact for end-user questions.

   I deliver

   • A written deployment runbook, reviewed before cutover.
   • A drilled rollback path. We test the rollback in staging first.
   • On-the-day support during cutover.
   • Bug fixes for 12 months, free, defined as: behaviour that does not match the agreed scope.
   • A support inbox with a stated response SLA.
   • Quarterly check-ins for the first year.

   Next: After 12 months, you decide whether to renew on a maintenance retainer or end the engagement.

6. 06

   Optional ongoing maintenance

   Month-to-month From $500/mo

   For when the project is live and the bug fix window has ended. No lock-in, no minimum term beyond the current month.

   You bring

   • A list of what you actually want covered: hosting, dependency upgrades, on-call, small features.
   • A budget you are comfortable with, even if it is small.

   I deliver

   • A short, written maintenance scope and SLA.
   • A monthly summary of work done, hours used, and what is queued.
   • Cancel anytime with 30 days notice.
   • Honest advice when you no longer need me. I will tell you so.

   Next: Or none. The relationship ends cleanly the moment you decide it should.

Communication during the build

Frequently asked

What if my project changes mid-build?

Scope changes are normal. They get a written change order with a new fixed price. Nothing changes in the code until you sign that change order. No surprise invoices, ever.

What if a milestone misses?

You only pay for milestones you accept. If I miss one, you can cancel the project and walk away owing only what was delivered to that point. The contract has the exit clause spelled out plainly.

Who owns the code?

You do. Code is committed to your repo from day one. I keep no escrow rights, no licensing strings. If we part ways, you keep everything.

Do you sign NDAs?

Yes. Either yours or mine. Mutual NDA before discovery for sensitive projects is normal.

Do you work on-site?

Mostly remote from Auckland. I will come on-site for kickoff, key reviews, and cutover when it makes a real difference. Travel inside Auckland is included; further travel is at cost.

What if I already have developers?

Even better. I work alongside in-house teams regularly: code review, architecture, integration help, or filling a specific skill gap. The process above flexes to match your existing rituals.

Do you do hourly?

Only for support, consultancy reviews, and ongoing maintenance. New builds are fixed-price. That is how you get an honest estimate instead of a meter running.

How fast can you start?

Discovery calls usually inside the same week. Proposals inside 3 business days of discovery. Build start depends on existing commitments, typically 2 to 6 weeks out.