Four ways in.One fixed scope each.
Every engagement is priced and dated before it starts. Pick the one that matches where you are; if none of them do, the discovery call sorts it out.
| No. | Service | Who it's for | Timeline | Starting from |
|---|---|---|---|---|
| S1 | Prototype → production | Founders with a no-code build | 4–8 weeks | ₦14m / $24k |
| S2 | Product design | Teams with devs, no designer | 2–4 weeks | ₦9m / $16k |
| S3 | Full-cycle build | SMEs digitising operations | 8–14 weeks | ₦26m / $48k |
| S4 | AI & automation | Operations with manual steps | 3–6 weeks | ₦10m / $18k |
| S5 | Custom scope | Scope beyond the four bands | Set in scoping | Priced after discovery |
Bands are the starting point for a fixed scope, not an hourly estimate, and most engagements land above them. The naira and dollar figures are priced to their own markets rather than converted from one another. The final number is fixed in writing after the discovery call, and it does not move afterwards unless you change the scope.
Prototype → production
Your Lovable or Bubble build, rewritten as a product that survives real users and real load.
A rebuild, not a patch. We read the prototype you already have, keep the product decisions it proved, and re-implement it on a stack that survives real traffic, real data and a real team. Your users move across on a migration plan with a rollback, so nobody loses an account on launch day.
For founders whose no-code build has started to hurt: the data model is bending, the monthly bill climbs with every user, and you cannot hire a developer to work on it. If your prototype is still cheap and still answering questions, you are not ready for this yet, and we will tell you so.
- Audit of the existing prototype and data
- Production architecture and stack decision
- Rebuild of the core flows
- Data migration with a rollback plan
- Deploy, monitoring, handover
Only in that it gets faster. The migration runs with a rollback plan, and we cut over once the new build has been tested against real data.
Yes. Most rebuilds keep the interface people already know and change what's underneath, unless you specifically want a redesign.
Then we keep them. The audit's job is to separate what proved itself from what was scaffolding.
Product design
Flows, screens and a component system your developers build from directly, with the states and edge cases drawn, not left to interpretation.
Flows, screens, and a component system your developers can build from without asking a question every hour. Every state is drawn, including empty, loading, error and permission-denied, because those are the screens that get invented badly at 2am when they aren't specified.
For teams with engineers but no designer, and for founders who need the product decided before they spend build budget. If you need a logo and brand identity, that's a different job and we'll point you somewhere better.
- User flows for the core journeys
- High-fidelity screens, desktop and mobile
- Component library with states
- Design tokens handed to code
- One round of usability testing
Yes. The design files and the exported design tokens, in your account, from the first week.
Yes. If one exists we extend it rather than replacing it, which is usually cheaper and always less disruptive.
Good. That conversation happens during design, not after the build. Engineering feedback shapes the flows before they're signed off.
Full-cycle build
Discovery through launch for one product: a web app, a mobile app, or the internal portal your operation currently runs on spreadsheets.
Discovery through launch for one product, run in two-week sprints. Every sprint ends with a live URL you can open and click, and the roadmap is re-published so you can see what shipped, what slipped, and what's next.
For SMEs digitising an operation that currently runs on spreadsheets, shared inboxes and WhatsApp, and for founders taking a validated idea to a first real release. If the scope is genuinely open-ended, start with discovery only.
- Discovery workshop and written scope
- Design (as S2, scoped to the build)
- Engineering in two-week sprints
- QA, accessibility and performance pass
- Launch plus 30 days of support
It gets priced in writing and you approve it before anyone builds it. The roadmap is updated so the change is visible, not absorbed silently.
About two hours a week: one demo, plus decisions only you can make.
Yes, on infrastructure registered in your name so it transfers cleanly at launch.
AI & automation
The steps someone on your team does by hand every day, such as quoting, triage, reconciliation and reporting, moved into software, with a human still in the loop where it matters.
We map the manual work first, then automate the parts that are safe to automate and leave a human in the loop where a wrong answer is expensive. Every deployment ships with an evaluation harness, so accuracy is a number you can watch rather than a claim.
For operations where someone spends hours a day on quoting, triage, reconciliation or reporting. If the underlying process isn't written down anywhere yet, the mapping is the first deliverable, because automating a process nobody agrees on just produces faster confusion.
- Process mapping of the manual work
- Model and tooling selection
- Integration with your existing systems
- Evaluation harness and accuracy baseline
- Escalation paths for the edge cases
You get a baseline measured against real examples before launch, and the same harness runs afterwards so drift shows up early.
They escalate to a person by design. The system is built to know what it doesn't know.
No. The integration is written so the model behind it can be swapped without rewriting the workflow.
Custom scope
Multi-product platforms, regulated builds, migrations off something large, or a scope that spans more than one of the four. Anything above the bands is quoted on its own terms.
The four bands above exist so nobody has to book a call to find out roughly what this costs. A band is not a cap, though. When the work is genuinely bigger than the shape it is being poured into, saying so is cheaper for both of us than pretending it fits and finding out in week nine.
Frequently asked
Fixed scope, fixed price, agreed in writing after the discovery call. If scope changes mid-project, the change is priced and approved before we build it. No surprise invoices.
You do. Repositories and accounts are transferred to you at launch, not licensed back to you.
30 days of support are included with every full build. After that, a maintenance retainer is optional. Nothing is forced.
That's what the discovery call is for. You'll leave with a written recommendation, including "you don't need us yet" when that's the honest answer.
Yes. Engagements run async with a weekly live demo, and we quote in both NGN and USD.
Often, yes. It starts with an audit of what exists so nobody promises a timeline before reading the code.
Not sure which one you need?
That is what the discovery call is for. Thirty minutes, and you leave with a recommendation in writing, including "you don't need us yet" when that is the honest answer.