WordPress websites and business systems
Start

When a you need a better solution, we build one.

Custom WordPress plugins and business software for the part of your operation no off-the-shelf product does your way. Built properly, documented, owned by you, and with no per-seat license growing every time you hire someone.

Talk about your build See how we build Timing depends on the rules and integrations.
01 / Where this starts

You have hit the end of what configuration can do.

A

The rules are yours alone. Eligibility, pricing or compliance logic no plugin author has ever had to think about.

B

Somebody has to prove it later. An auditor, a payer or a board needs a record that holds up, not a spreadsheet export.

C

Per seat pricing has become the problem. The software works, and the licence bill grows every time you hire.

Two more we hear constantly: it has to be captured on a phone where the work happens, and two systems need to agree without anyone retyping between them. If two of these are true, a build usually costs less over three years than the workarounds do.

02 / The decision

Configure it, or build it.

Keep stacking plugins

Another add on, another integration, another workaround held together by one person who knows the trick. It works, until an update lands or that person leaves.

✕ It breaks in a way nobody can fix
Write the software

One plugin that does your job, in your words, with the permissions and the record keeping built in. Owned by you, documented, and maintainable by anyone competent.

→ Continue below

We will tell you which side you are on before you spend anything. Configuration is cheaper than code, and when the Gravity stack fits, that is what we recommend and what we build on a Growth Plan.

03 / How we build

Five stages. The riskiest part first.

You see working software early rather than a status report, and you own what comes out of every stage. Scroll through a build.

Fig. 1 / The shape of a build Five stages
01Scope02Prototype03Build04Harden05Hand over
04 / Stage 1 of 5 / Scope

We write down what it has to do.

Rules, roles, data, reporting and the awkward exceptions nobody documents. Who is allowed to do what, what has to be proven later, and what the system must never let happen. You get the specification whether or not we build it.

Fig. 2 / Scope Stage 1 of 5
01Scope02Prototype03Build04Harden05Hand over
Half day With the people who do the work, and whoever gets audited Written down Rules, roles, data model, integrations and reporting Yours either way Take the spec elsewhere if you want a second quote
05 / Stage 2 of 5 / Prototype

The riskiest part gets built first.

Not the easiest, the riskiest. If the whole idea depends on a check in from a phone, a state system accepting your export, or a rule nobody can quite articulate, that is what we prove in the first weeks.

Fig. 3 / Prototype Stage 2 of 5
01Scope02Prototype03Build04Harden05Hand over
Week one The part most likely to sink the project Real data Tested against your actual cases, not happy path demos Cheap to stop If it will not work, you find out before the budget is gone
06 / Stage 3 of 5 / Build

Delivered in milestones you can use.

Written as a proper plugin in version control, not snippets pasted into a theme that the next update eats. Your staff test real cases as each milestone lands, so the thing that ships is the thing they will actually use.

Fig. 4 / Build Stage 3 of 5
01Scope02Prototype03Build04Harden05Hand over
Milestones Working software you can try, not status reports Version control Every change tracked, every release tagged Your team Testing as we go, not in one panicked week at the end
07 / Stage 4 of 5 / Harden

Then we try to break it.

Permissions, validation, logging, backups and a rollback path. After that we attack it the way a tired employee on a cracked phone in bad signal will attack it, because that is who uses it at 6am.

Fig. 5 / Harden Stage 4 of 5
01Scope02Prototype03Build04Harden05Hand over
Permissions Nobody sees a record they should not Logging Who did what, when, in a form that holds up later Rollback A way back if a release goes wrong
08 / Stage 5 of 5 / Hand over

Documented, and in your name.

The repository, the documentation, an admin walkthrough and the licence keys. Plus a support window, and a plan afterwards if you would rather we kept it current than hand it to someone internally.

Fig. 6 / Hand over Stage 5 of 5
01Scope02Prototype03Build04Harden05Hand over
Repository Yours, with a readme another developer can follow Walkthrough Recorded, so new staff can be trained without us After launch Maintained on a plan, or handed to your team
09 / Recent builds

Software we built, and what it replaced.

The visit verification system is the one we can show. Caregivers were checking in through a per person subscription, and the agency needed the record on its own site.

Home care Replaced per caregiver SaaS
Electronic visit verification

Caregivers check in and out at the point of care from a phone, visits are verified against the schedule, and records export in the format the payer requires.

Built on Custom plugin, no Gravity dependency
Owned by The agency, outright
10 / What you end up owning

It is yours in a way a subscription never is.

This is the whole argument for building rather than renting, so it goes in the agreement, not just on a page.

The code A real plugin in a repository you own, not snippets in a theme
The documentation What it does, how it is configured, where the data lives
The licences Third party licences and API keys registered in your name
The exit Hand it to another developer and they get a clean codebase
The savings No per seat licence growing every time you hire someone
11 / Your route

Which one is you?

Most people are the middle one, so that is what is showing. Pick another and the option below changes.

  We need to think it through

We know the problem. We cannot yet say what the software should do.

Most clients Build it and keep it running

We want the build, the site it lives on, and someone keeping both current.

  Fixed scope, hand it over

It is well understood, and we have someone internally who will own it after.

Build on a plan $1,600 / month

The build, the site it lives on, and the upkeep afterwards on one monthly fee. This is where most clients land, because custom software is never finished: rules change, PHP updates, and someone has to keep it current.

Scope, prototype and build included
Hosting, updates, backups, monitoring
WordPress and PHP compatibility maintained
Changes included, not quoted
Your repository and documentation
Monthly report and strategy call
Book a call about this Six or twelve month start, then month to month
End / Three ways to start

Pick the one that matches how sure you are.

Route 1 Book a call

Thirty minutes. Tell us the part of the business software has never fit, and we will say whether it is a build or a workflow.

Route 2 Scope session

Half a day with the people who do the work, and a written specification you keep whether or not we build it.

Route 3 Start a plan

You already know what needs building. Choose a plan and we will have your scope session booked this week.

Common questions
Does this have to be WordPress?

No. Most of our work sits in WordPress because that is where the client’s site and users already are, but a build can be a standalone application with WordPress as the front door, or no WordPress at all.

Do you only build on Gravity Forms?

No. The Gravity stack covers a lot of workflow ground fast, and when it fits we use it. When the rules, the data model or the proof requirements outgrow it, we write the plugin instead. The EVV system is an example of the second.

Who owns the code?

You do, on final payment, including the repository. We keep generic patterns and internal libraries, never your logic.

What about WordPress and PHP updates?

Custom code needs maintenance like anything else. We test against new versions and patch it, on a plan, a maintenance agreement, or a quoted update.

Can our own developer take it over?

Yes, and that is why we hand over a documented repository. Several of our builds are maintained by an internal team after launch.

How long does a first version take?

It depends on the rules and the integrations. The riskiest part works early, so you learn fast whether the idea holds.

How we work
The quote is the price

Quoted after scope, never before. If we misjudged it, that is ours.

We will tell you no

If configuration would do the job, we say so and build that instead.

You own everything

Repository, documentation and licences, all in your name.

A person, not a portal

You talk to the developer writing the code.