Custom software development | Perth + Australia
Custom software, built around how you work.
Based in Perth and working across Australia, we build bespoke software for established businesses: internal tools, client portals and integrations. We work out with you what to buy, configure or build, then test and release the custom parts in stages.
Free 30-minute conversation. We'll review your main constraint and agree where to start.
Who it's for
For businesses that have outgrown spreadsheets and workarounds
You don't need custom software for everything. It earns its place when a process is central to how you make money and the available products force your team to double-handle work.
Signs it's worth a conversation
- Jobs, quotes or deals are tracked across spreadsheets, inboxes and people's memory.
- You have a CRM, but the team works around it rather than in it.
- Customers or partners call and email for status updates you could show them directly.
- The same details are typed into two or three systems because they don't talk to each other.
What we build
Custom work is kept to the parts of a process that products don't handle well, and it usually sits alongside the systems you're keeping.
- 01
Internal operations tools
Job tracking, approvals, scheduling views and checklists, so work moves without chasing.
- 02
Client and partner portals
Secure places for customers or partners to see status, approve work, upload documents and get updates.
- 03
Quoting and pricing tools
Quotes built from maintained price lists and rules, with margin checks before anything is sent.
- 04
Integrations
Connect your CRM, accounting, job management, forms and email so data is entered once, and extend a CRM where it falls short.
- 05
Dashboards
Live views of pipeline, jobs and performance built on your operational data.
- 06
Data migration
Move records out of spreadsheets or legacy systems, as far as their exports and APIs allow, with checks so nothing important is lost.
Buy, configure or build
Decide what to buy, configure or build before anyone writes code
Most good systems mix these approaches, and extending a product sits between configuring it and building from scratch. Custom work is justified where a process is central to how you win or deliver work and no product handles it without workarounds.
| Approach | Fits when | Watch for | Typical examples |
|---|---|---|---|
| Buy | Fits whenThe process works the same way in most businesses, and a product handles it well as it comes. | Watch forFeatures nobody uses, and licence costs that grow with headcount. | Typical examplesAccounting, payroll, email, document signing |
| Configure | Fits whenA product covers most of the process once its fields, workflows and permissions are set up. | Watch forCustomisation so heavy that upgrades become risky, or key rules hidden in one vendor's settings. | Typical examplesCRM pipelines, booking, job management, help desks |
| Extend | Fits whenA product fits, apart from one missing piece: a connection, a calculation or a view for customers. | Watch forSmall extensions that pile up without shared documentation or monitoring. | Typical examplesIntegrations, quoting calculators, portals on existing data |
| Build | Fits whenThe process is how you win or deliver work, and products force workarounds or double entry. | Watch forHosting, security, support and change over the software's life, not just the first build. | Typical examplesJob and approval workflows, client portals, internal operations tools |
The recommendation is written down with its reasons. If a product does the job, that's what we recommend.
Decision criteria
The questions behind the recommendation
Each part of the process is assessed against the same questions, so you can check the recommendation rather than take it on trust.
What we assess
- Advantage: does this process set you apart, or is it the same in every business?
- Coverage: how much of it does an existing product handle without workarounds?
- Connections: which systems must it exchange data with, and do they offer reliable APIs?
- Data and access: what sensitive information it holds, and who needs to see or change it.
- Change: how often the process changes, and who will make those changes.
- Lifetime cost: hosting, support, security updates and improvements, not just the first build.
End-to-end workflow
From enquiry to paid invoice
How a field service business might combine bought, configured and custom software, with each step passing data to the next so nothing is typed twice.
| Step | What happens | System | Approach |
|---|---|---|---|
| 1. Enquiry | What happensA web form or call creates a contact and an opportunity, tagged with its source. | SystemCRM | ApproachConfigure |
| 2. Site visit | What happensThe customer books a visit, and the technician's calendar and the CRM record update together. | SystemBooking tool and CRM | ApproachConfigure |
| 3. Quote | What happensThe estimator builds the quote from a maintained price list and the site notes, and the margin is checked before it's sent. | SystemQuoting tool | ApproachBuild |
| 4. Acceptance | What happensThe customer reviews and accepts the quote online, and the opportunity moves to won. | SystemClient portal | ApproachBuild |
| 5. Job created | What happensThe accepted scope, address and contact details create a job without re-keying. | SystemJob management | ApproachExtend, with an integration |
| 6. Delivery | What happensTechnicians complete checklists and photos on their phones, and the customer sees progress in the portal. | SystemJob management and portal | ApproachConfigure and build |
| 7. Invoice and payment | What happensCompletion raises the invoice, and payment status flows back to the CRM and the portal. | SystemAccounting software | ApproachBuy, with an integration |
| 8. Review and rebooking | What happensA review request and a service reminder are scheduled from the completion date. | SystemCRM automation | ApproachConfigure |
Only the quoting tool and the portal are custom builds here. The rest are bought or configured products, joined by integrations. Where that line falls depends on the business.
Specification, integration, testing and release
What you receive before development starts
Before development starts, you receive a written scope to check and agree with us, so everyone can see what the first release will do and how it will be tested.
Illustrative example, not a client project: the scope for the quoting tool in the workflow above.
- Workflow: the estimator builds a quote from the site notes and price list, the margin is checked, a manager approves any exception, and the customer accepts online.
- Roles and data: estimators create quotes, managers maintain the price list, and customers see only their own quotes, never margins or internal notes.
- Integrations: the CRM stays the source of truth for contact details, an accepted quote creates the job, and a failed sync alerts a named person.
- Acceptance criteria: a quote below the agreed margin can't be sent without manager approval, and a customer can't open another customer's quote.
- Pilot scope: one team and one service line first, with the current quoting process as the fallback until the agreed checks pass.
Integrations that keep working after launch
Custom software depends on its connections. Each integration is specified before it's built: which system is the source of truth for each field, what triggers a sync, and what happens when the other system is unavailable.
- Official APIs and webhooks: used wherever the connected systems provide them, rather than screen-scraping or shared spreadsheets.
- No duplicates on retry: each message carries an identifier, so a repeated delivery updates the record instead of creating a second one.
- Retries and alerts: failed syncs retry automatically, then alert a named person with the record and the error.
- Logged and traceable: every sync is logged with the record IDs on both sides, so mismatches can be investigated.
- Limited access: each integration's credentials allow only what it needs, and are stored outside the code so they can be changed without a release.
Testing against agreed scenarios
Acceptance scenarios are written with your team during specification, in plain language: in this situation, when someone does this, this should happen. They become the test plan.
- Business rules: automated tests for calculations and rules, such as quote totals, margins and approval thresholds.
- Integrations: tested against sandbox or test accounts where the connected systems provide them, including failure cases.
- Access: each role is tested, including checks that a customer can only see their own records.
- User acceptance: the people who will use the software run the scenarios on a staging copy before release.
- Devices: portals and mobile screens are checked at phone and desktop sizes, and with a keyboard and screen reader.
Releases you can roll back
Software is released in stages, starting with a pilot group or one part of the process, so problems surface while they're small.
- Staging first: every change is checked on a staging environment that mirrors the live system.
- Backups and rollback: data is backed up before each release, and every release has a written rollback step.
- Release notes: what changed, who it affects and anything users need to do differently.
- Monitoring: errors and failed syncs are watched closely in the days after a release.
- Handover: an admin guide, a runbook for common issues and a change log, kept up to date as the software changes.
Delivery
How we deliver software
- 01
Discovery and decision
Walk through the process with the people who do it, and agree what to buy, configure or build.
- 02
Specification
A written scope with acceptance scenarios, integrations, data handling and support after launch.
- 03
Build in stages
Working software early on a staging environment, tested with your team so feedback shapes the next stage.
- 04
Release and support
A staged release with rollback steps, training and handover, then monitoring, support and improvements.
Client work involving CRM and operations systems
Scope of related past work. Each write-up sets out what was built and how its results were measured.
Questions we're often asked
Can you work with the systems we already have?
Usually. We build around the systems you're keeping, through their APIs, and only suggest replacing one when it can't support a core requirement. If a CRM change makes sense, we'll plan it so your team isn't left without a working system.
What happens after launch?
We provide training and handover, then ongoing support. Monitoring, improvements, reporting and new features can continue after launch if that suits you.
How do you handle security and access?
Access controls, backups, hosting and how sensitive data is handled are part of the specification, and access is tested for each role before release. If you have specific compliance requirements, tell us early so they're designed in.
How long will it take?
It depends on scope, integrations and how quickly decisions can be made. We deliver in stages and give you a timeline for each stage in the proposal.
Free 30-minute growth review
Talk through what you need built
Tell us about the process or system that's holding things up. We'll come back to arrange a growth review, a practical conversation about the options, including whether custom software is the right answer.
Every engagement is bespoke: we agree the scope and terms once we understand your business and priorities.
Related services
- Business growth consulting
- Marketing consulting
- SEO
- CRM implementation
- AI consulting
- Business process automation
- All services