Custom software prototype
Show them the software instead of the slide deck. Two weeks from the kickoff workshop.
You bring the idea and the people who will use it. We turn it into software that runs, and hand it over with the source code and the documentation. Two weeks from the kickoff workshop, on time and matching what we wrote down, or we refund your fee.
Software that runs, end to end. Real logic, real screens, a link you can send to a stakeholder who then works through it alone.
Two weeks from the kickoff workshop. Not two weeks from your first email. The clock starts the day we sit down and write the requirements together.
The On-Time Prototype Guarantee. On time, matching the written requirements, defects fixed at our cost, and built for at least 75% less than the conventional-build baseline we agree in writing. Otherwise you get your fee back.
Free call, no obligation. You leave it knowing what your prototype would cover and how long it would take, whether or not you hire us.
The estimate came back and the project went quiet
The software already exists in your head. Somebody has already put a number on it. Four months, a team of five, and a figure large enough to turn a project into a board decision.
So it waits. For the budget round, for the business case, for someone senior to be convinced by a document describing something nobody has seen. The requirements drift while it waits, because nothing tests a requirement like using it.
And the money that does get spent goes into the same shape of estimate that produced the delay. Code written by hand from scratch, against a plan approved before anyone could click anything.
How two weeks is possible
We write the requirements with you first, in one session, in plain sentences that a person and a model can both read. That document is the specification and the acceptance test at once, which is what the guarantee points at.
Then we generate. AI writes the first draft of the code against those requirements. The rest of the two weeks goes on the part AI does not do: reading it, testing it against your real cases, cutting what is wrong, hardening what you will show.
That is why the estimate is two weeks. Typing is no longer the slow part of building software. Deciding is, and we do the deciding with you on day zero.
What you get
One fixed scope, agreed in writing before anything is built.
A requirements workshop, two hours. You, us, and the people who will use the thing. We leave with a written specification in your words, and with the list of what is deliberately out of scope.
The build. Code generation, then testing and refinement against your real cases. You see it running partway through, so the first look is not on the last day.
A presentation session, two hours. We walk you and the people you need to convince through the working software, and through what full development would take from here.
The working software. Deployed somewhere you can open it, log in, and hand the link to somebody else.
The source code, in your repository. Yours from the first commit. If you continue with a different team, they pick it up and keep going.
Written documentation. What it does, how it is put together, and what the next developer needs to know before touching it.
What the two weeks look like
Day 0
The kickoff workshop. Two hours. We write the requirements together and agree what the prototype has to do. The clock starts here.
Days 1 to 7
Generation and build. You get a first running version to click before the halfway point.
Days 8 to 10
Testing and refinement against your real cases, and the fixes that come out of it.
Day 10
The presentation session. Two hours. The working software, the source code, the documentation, and a straight answer about the time full development would take.
Ten working days is two calendar weeks, counted from the workshop. If the prototype needs access to a system we do not have yet, the clock pauses until we have it, and we tell you the day it happens.
The On-Time Prototype Guarantee
On time, matching the written requirements, defects fixed at our cost, and built for at least 75% less than the conventional-build baseline we agree in writing. Miss one and we refund your fee.
This is a promise, not a track record. Every number on this page is something we owe you, with a refund behind it. None of it is a measurement of past work.
The baseline is agreed before we build, not after. In the workshop we write down what the same scope would cost to build conventionally, using the quote you already have or the day rate of your own team. That number goes into the contract and neither side can move it later.
On time means the date in the contract. Two weeks from the workshop, counted in working days, with the pause rule above written into the same clause.
Matching requirements means the document we wrote together. Anything that fails to do what the specification says it does is a defect. We fix defects against that specification at our cost, for thirty days after the presentation session.
How you claim. Email info@fijisolutions.net within thirty days of the presentation session, pointing at the term we missed. You get an answer within ten working days.
These terms go into the contract before we build, in these words. You can hold us to every one of them.
Who this is for
This is for you if
- You already have a budget allocated for software development, or a quote sitting in front of you.
- You can decide, or you can get the decision made in one conversation.
- Real people will use this, and you can get two hours of their time.
- You want to see it running before the full project is committed.
This is not for you if
- You need a production system on day ten. A prototype is built to be tested and shown, and hardening it is the next engagement.
- The requirements cannot be written down yet. Finding them is useful work and it is a different session.
- Nobody internally can spare two hours for the workshop.
- You want us to skip the workshop and build from a short brief. The guarantee rests on that document.
The questions we get asked
- What does it cost?
- We quote it after the first call, in writing, against what your prototype needs. There is no list price and no rate card. The fee is fixed before anything is built and does not move afterwards.
- Is a prototype the same as production software?
- No. It runs, it carries real logic, and people can work all the way through it. Making it survive load, real users and an audit trail is the next engagement, and we tell you at the presentation what that takes.
- Who owns the code?
- You do, from the first commit. It sits in your repository with the documentation next to it. If you carry on with another team, they read it and continue.
- AI wrote it. Should I trust it?
- Trust the review rather than the generation. Every line is read, tested against the requirements we wrote with you, and covered by the defect warranty above. The judgement stays with people.
- What happens after the two weeks?
- Three doors are open: MVP development, full development of the project, or maintenance once it is live. You are under no obligation, and the source code leaves with you either way.
Tell us what to build
Describe the software you want to see running. We will come back with what the prototype would cover and what it would take.
Two minutes to fill in. The message field is optional.
Prefer to skip the form? Book the call directly: Pick a time on Calendly
Free call, no obligation. You leave it knowing what your prototype would cover and how long it would take, whether or not you hire us.
We reply within one business day.