Custom software development

The first stage is about understanding the work, not writing a long specification. We talk to the people who use the current setup, follow one real case from start to finish and list every system, spreadsheet and hand-off it touches. For a larger project with an open scope, this is the $1,500 scoping sprint: in three to five business days you get a written plan, an architecture and a fixed price for each stage. The plan stays with you, whoever builds it.

From you we need a person who knows the process and can make decisions, access to the systems the software must connect to, with sandbox accounts where they exist, and real records with personal details removed. You don't need a technical specification. We write it with you, and you approve it.

Each week you get a short written update and a link to the latest build that you can click through yourself. The update says what was finished, what comes next and which decisions are waiting for you. The repository is open to you from the first day, so you see every change, not a summary of it.

Each stage plan sets out:

• The part of the workflow it covers, in steps your team will recognise
• Acceptance criteria you can check without reading code
• The systems involved and which one owns each piece of data
• Risks and open questions, named rather than hidden in the price

Custom software rarely fails because of one bad decision. It fails through months of status reports while the product never quite reaches its users. We plan the stages so that cannot happen quietly.

Every stage ends with software in use, not a demo. The first stage puts one complete path into production, even if it is narrow: one record type, one role, one report. Later stages widen it. If a stage shows that part of the plan was wrong, you find out after weeks, not at the end of the budget.

Acceptance criteria are written in plain language before a stage starts and become automated tests during it. A change in scope does not stretch the current stage; it goes into the next one with its own price. Architecture decisions are recorded in short decision records, so the reasons survive after the people who made them move on.

The engineering basics are in place from the first week: separate development and production environments, infrastructure defined in code and deployment through a pipeline, never from someone's laptop. In the freight brokerage platform, each API route runs as its own function, defined in infrastructure code and promoted from development to production through a gated pipeline. The guest benefits platform has automated tests, separate development and production stages, and a preview environment for every change.

Nothing changes hands at the end, because it was never ours. The repository, cloud accounts, domains and third-party services sit under your company from the first day. With each accepted stage you also get the source code with tests that run on every change, infrastructure as code for every environment, and a runbook for deploying, rolling back, restoring from a backup and rotating secrets. A service list names every external service, webhook and scheduled job, and who pays for each.

A handover call walks your team or your next developer through the system. From there you choose the next fixed-price stage, monthly support from $1,200 for monitoring, fixes and small changes, or your own team working from the documentation. Nobody needs our permission to continue.

Custom software is the broad option. A narrower service is often cheaper and faster:

• Launching a new product and still testing whether people will pay? Start with MVP development.
• Two systems that should share data but don't? API & system integrations connects them.
• One tool for a sales or operations team? See Custom CRM & internal tools.