Skip to content
Ackho
Software & product engineering

Software built like a craft, not a checklist.

Knowing what the business actually needs, and picking what to build it with, decides whether a system gets used, or gets quietly replaced by a spreadsheet.

Where we have experience

  • Banking
  • Government
  • E-commerce
  • Consumer technology
  • Energy and utilities

How the engagement runs

Four steps, and the price is fixed at the second.

The same shape as every Ackho engagement. The difference on a build is how early your own engineers are in the repository.

  1. 01

    Map the workflow

    Two weeks watching the work happen, including the spreadsheets nobody mentions at kickoff.

  2. 02

    Fix the scope and the fee

    A milestone plan with a fixed fee per milestone and an explicit list of what we are not building.

  3. 03

    Build in the open

    Weekly demos against the plan. Your engineers have commit access from week one, not at handover.

  4. 04

    Hand over

    Runbook, architecture decisions written down, thirty days of support, and no dependency on us.

What changes

Fewer steps, not a bigger system.

A field service business where the job existed in five places and none of them agreed. The rebuild was smaller than the brief, because most of the brief described repair work.

  • A spreadsheet holding a critical process together, maintained by one person
  • Two systems that disagree, reconciled by hand every week
  • An off-the-shelf tool that does 80%, where the other 20% is the actual work
  • A previous agency’s system nobody can safely change

What you get before you commit

The estimate is a document, not a number.

Two weeks of mapping produce a milestone plan with a fixed fee against each milestone, a named owner, and a written list of what we are not building. You can take it to someone else.

  • A fee per milestone, invoiced on acceptance rather than monthly
  • A named owner against every workstream, agreed before you sign
  • An explicit exclusions list, agreed before anything is signed
  • The mapping phase stands alone if you decide not to continue

Engagement plan

Field service job system

Building services · 40 engineers on the road

Duration

14 weeks

  • Fixed fee
  • Billed by milestone
  • You own the code

A plan for a project of this shape, not a client’s, since we do not publish those. Every engagement gets one of these before any code is written.

  1. 01

    Map the workflow

    Weeks 1–2

    Owner: Both leads

    10% of fee
  2. 02

    Job intake and customer records

    Weeks 3–6

    Owner: Engineering lead

    25% of fee
  3. 03

    Dispatch and the mobile view

    Weeks 7–10

    Owner: Engineering lead

    30% of fee
  4. 04

    Close-out and invoicing

    Weeks 11–13

    Owner: Strategy lead

    25% of fee
  5. 05

    Handover

    Week 14

    Owner: Both leads

    10% of fee

Typical shape

What a build usually looks like.

Small enough that the people building it hold the whole system in their heads, and short enough that the workflow has not changed by the time it ships.

10–16weeks end to end, including the mapping phase

Scoped before it is priced

The mapping phase produces the fee, so the number is based on the work as it actually is rather than on the brief.

Handover is a deliverable

Runbook, architecture decisions with the rejected options, and your engineers already committing before we leave.

Stack

What we build with.

Boring, well-understood technology that your next engineer can already read. We will use yours instead if you have a standard worth keeping.

  • TypeScript
  • React
  • Node
  • Python
  • Postgres
  • Redis
  • AWS
  • Cloudflare
  • Terraform
  • Docker
  • GitHub Actions
  • Playwright

FAQ

Building custom software with us

How much does custom software cost in Singapore?
It depends on the scope, so there is no headline number. Scoping comes before any code is written, and its job is to surface every feature the build actually needs, which is what stops things appearing on the invoice later. A build of this size is then billed by milestone against that written plan rather than by the hour.
How long does a custom build take?
Most systems of the size described here run ten to sixteen weeks including the mapping phase. If a build genuinely needs longer, we phase it so something is live and useful before the end.
Can you take over a codebase built by someone else?
Often, yes. We start with a short assessment rather than a promise. Some inherited systems are worth extending and some are cheaper to replace, and you should get that answer before you pay for either.
Do we own the code?
That depends on the arrangement, and we are flexible on both. If you want the code, it is yours from the first commit with no licence back to us, and your engineers have repository access throughout. If you would rather not own or maintain it, we keep it and run it for you for a smaller project fee plus a monthly subscription. Handover includes the runbook and the architecture decisions in writing either way.
What happens after launch?
Thirty days of support is included. After that a maintenance retainer is available, but the handover is deliberately good enough that you are choosing it rather than trapped in it.

Tell us the partthat is costing you.

One call. We tell you what we would build, what we would not, and what it costs, before either of us commits.

Start a projectFractional CTO

Tell us the workflow.

It goes to the people who would do the work, not to a sales inbox.

Used only to reply to you. We won't add you to a list or share it with anyone.

Ackho