Process
How a project actually runs.
Six phases. Honest pipeline. Clear handoffs. Written contracts. No surprises and no dead ends.
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.
-
01
Free 30-minute discovery call
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.
-
02
Fixed-price written proposal
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.
-
03
Milestone-paid build
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.
-
04
UAT with your real users
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.
-
05
Deployment plus 3 months included support
Production deploy with rollback drilled. The first three months of support are 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 3 months, included, defined as: behaviour that does not match the agreed scope.
- A support inbox with a stated response SLA.
- Monthly check-ins through the included support period.
Next: After three months, you can move onto an annual support package or a month-to-month maintenance retainer, or end the engagement.
-
06
Annual support package or month-to-month
For when the included three months have ended. An annual support package keeps everything covered for a fixed yearly price, or stay flexible month-to-month. No lock-in.
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.
Payment schedule
No hidden fees. Every invoice is tied to a phase you have signed off. If you cancel, you only pay for what has been accepted.
| Phase | Share | Notes |
|---|---|---|
| Discovery call | 0% | Free. |
| Proposal | 0% | Free, even if you walk away. |
| Project signed | 20% | Deposit invoiced on signing. |
| Per milestone | 60% | Split across the build milestones, each invoiced on milestone sign-off. |
| UAT signed | 15% | Invoiced when you accept UAT. |
| Go-live | 5% | Invoiced on production cutover. |
All amounts in NZD, GST exclusive. Payment terms: 7 days from invoice. NZBN supplied on request.
The paperwork, in plain sight
Every fixed-price build is backed by two short, plain-English documents: a mutual NDA before we discuss specifics, and a build agreement before any money moves. Here is what they cover, so nothing in them is a surprise on the day you sign. These are illustrative summaries; your engagement gets its own documents.
Mutual NDA
Signed first for anything sensitive. It protects both sides equally.
- Protects both parties' confidential information, not just mine.
- Used only to discuss and deliver your project.
- Returned or destroyed on request once we are done.
- Protects information without restricting either of us from doing business.
Build agreement
The fixed-price contract for the work itself. Plain English, no traps.
- Fixed fee, split into milestone instalments. Each invoice due in 7 days; the next milestone starts once the last is paid.
- You own the IP in everything built for you, assigned on full payment, with source in your own repository.
- I keep my pre-existing tools and libraries, with a perpetual licence to you for anything embedded in your deliverables.
- A warranty that it works to the agreed scope, with three months of maintenance included from go-live.
- After that, optional support: a fixed annual maintenance agreement, or as-needed at a stated hourly rate. No lock-in.
- Either side can exit on 14 days notice; you pay only for work delivered to that point.
- Liability capped at fees paid. Governed by New Zealand law.
Smaller projects are contracted directly with Delphi Consultants. Larger engagements are contracted and invoiced through our associated company, Cyphonica Security Services Ltd, working under the Delphi Consultants brand. You always know which entity you are dealing with before you sign.
Communication during the build
Weekly 15-minute check-in
Same time every week. Three questions: what shipped, what is in flight, what is blocked. If there is nothing to discuss we cancel and reclaim the time.
Milestone demo
Live walkthrough of the working software at every milestone. Recorded if you cannot attend. Followed by a 1-page written summary.
Direct line
You always have my mobile and email. No ticketing system between us during a build. Critical issues get a same-day response.
What you get at the end
- Working production software, deployed and running.
- All source code in a repository you own.
- A deployment runbook and a rollback plan, both tested.
- End-user documentation for the parts that need it.
- Internal documentation: architecture diagram, integration map, environment notes.
- 3 months of included bug fixes from go-live, with annual support packages available after.
- An exit document: how to take the system to another developer if you ever need to.
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.
Ready to start?
The whole thing begins with one 30-minute call. No deck, no pitch, no obligation.