The problem we solve
New products tend to fail in one of two ways. In the first, the feature list grows at every meeting, the scope inflates, launch keeps sliding, and the budget is spent before a single user has touched anything — and when it finally ships, nobody can tell which part is responsible for the result. In the second, a throwaway prototype is rushed out with no foundation; it survives the demo and collapses under the first serious week of use, so everything gets rebuilt. We work in the space between: a tight scope built on a foundation that can carry the next version.
Expected outcomes
- Early clarity on whether the idea deserves scale, before the full budget is committed.
- A product real people are using rather than a deck describing what it could be.
- Controlled scope that protects the launch date from creeping requirements.
- A technical base you can extend, instead of a prototype that gets discarded.
- Instrumentation that shows where users stop and what they come back for.
- A prioritised next round grounded in how the product is actually used.
Who this is for
- Founders with a defined idea who need a team that can execute it properly.
- Established companies testing a digital line of business outside their core systems.
- Internal innovation teams that need evidence before requesting a larger budget.
- Service businesses running a manual process they want to turn into a product.
- Teams with an existing audience looking to launch an adjacent product quickly but carefully.
Use cases
- Launching a marketplace that formalises a process currently run over calls and messages.
- Turning a spreadsheet-driven service into a web application customers use directly.
- Testing a new subscription model with a limited segment before wider release.
- Building a customer portal that takes routine requests off the service team.
- Proving an internal concept ahead of a larger funding decision.
- Relaunching a stalled product with a narrower scope and a sound technical base.
Deliverables
- A live product on your own domain, in the hands of real users.
- A complete code repository in your company name, with operational documentation.
- Design files and the component system used in the build.
- Configured cloud infrastructure with staging and automated deployment.
- An analytics view covering the events tied to the agreed success measures.
- The deferred feature list, ordered by impact and ready for the next round.
- A knowledge-transfer session for your team or whoever continues the work.
Project phases
Framing
A workshop defining the problem, the user, the core hypothesis and how success will be measured.
Scoping
Agreeing the core path and the deferred list, with a realistic technical and timeline estimate before commitment.
Design
Core journeys, screens and a prototype reviewed and approved before development begins.
Build
Short delivery cycles with continuous deployment to a staging environment your team can use.
Controlled launch
Going live with a limited group of users, monitoring performance and gathering feedback closely.
Read & decide
Reviewing usage against the agreed measures and prioritising the next round of work.
- Estimated timeline
- 6 to 14 weeks
- An estimate that depends on scope and how quickly reviews come back — not a contractual commitment in itself.
- Pricing
- After scoping
- Cost varies with the number of core journeys, the complexity of the business rules and the external integrations involved. We prefer to price a short framing phase separately, then issue a scoped build proposal based on what it produces.
Scope and working details
What is in and out of scope, how we work, and what we need from you.
What is included
- A framing workshop on the problem, the target user and the hypothesis being tested.
- Scope reduction to the core path that proves value, with everything else explicitly deferred.
- Agreed success measures defined before the build begins.
- Design of the core journeys and screens, in Arabic and English.
- Development of the front end, back end, database and user permissions.
- Integration of the external services required, such as payments, notifications or email.
- Cloud infrastructure, an automated deployment pipeline and a separate staging environment.
- In-product analytics tracking the events tied to your success measures.
- Testing, a controlled launch, and a review session on what real usage revealed.
What is not included
- Fundraising materials or representing the product to investors.
- Market sizing, commercial feasibility research and financial modelling.
- Obtaining licences or regulatory approvals required to operate the business.
- Marketing campaigns and user acquisition after launch.
- Features outside the approved scope; these are logged and estimated as a later round.
- Engineering for enterprise-scale load before the need for it is demonstrated.
How we work
We open with one question: which assumption, if wrong, sinks the whole thing? The first version is built to test exactly that, and everything else goes onto a visible deferred list so postponement never feels like neglect. Work runs in short cycles, each ending with something you can open and use on a staging link, so progress is never a mystery until handover. We write production code rather than demo code, because a version that works gets extended, not thrown away. And after launch we sit with you over the usage data to decide together whether to scale, adjust or stop.
What we need from you
- A product owner on your side available to make decisions quickly during the build.
- Access to prospective users for early testing.
- Clarity on the business model and the operational and legal constraints around it.
- Accounts for required external services, such as payments or messaging, in your company name.
- A stated position on what can be deferred — controlled scope is what makes the date achievable.
Methodology and technology
We choose familiar, stable technology you can hire for later: a React front end on Next.js, a Node.js or Laravel back end depending on the project and your team, and PostgreSQL for data. Cloud hosting with an automated deployment pipeline, a separate staging environment and scheduled backups. Role-based authentication and permissions, encrypted transport, centralised logging and error tracking. In-product analytics on a predefined event map. Delivery in short cycles with code review and automated tests on the critical paths.
How this connects to the rest of our work
A service rarely works alone. These come before it or alongside it, and these are the solutions it forms part of.
Services that work with it
UI/UX and Product Design
Research, tested prototypes and a documented design system — in Arabic and English, ready for engineering.
Web Applications and SaaS Development
A web app or SaaS product built around your real process — permissions, integrations and code you own.
Mobile Application Development
An iOS and Android app with one coherent experience, plus accounts, code and release pipeline you own.
Part of these solutions
Frequently asked questions
How is this different from a quick prototype?
A prototype explains an idea and is then discarded. What we build runs, takes real users and, where needed, real payments, on code and infrastructure that can be extended. The difference is not the number of features but the quality of the foundation: we narrow the scope without lowering the build standard.
How do you stop scope creeping during the project?
Scope is agreed in writing at the framing stage, and every new request is logged with an estimate of its effect on date and cost. We do not reject new thinking, but we never absorb it silently. The call stays yours, made with the trade-off visible.
What if the results show the idea does not work?
That is a useful result and part of why this route exists — learning it early at contained cost beats learning it after the budget is gone. We review the data with you and lay out the options: adjust the concept, target a different segment, or stop. No one can commit to a market outcome, but we can design the test to give you a clear answer.
Who owns the code and the accounts?
You do, from day one. The repository, cloud infrastructure and third-party service accounts are created in your company name and under your access, never ours. Nothing stays parked on our side at handover.
Can our own team continue development afterwards?
We build on widely used technology, document the architecture and the technical decisions behind it, and run a knowledge-transfer session at handover. Many clients continue in-house; others keep us on as the engineering team or under a monthly support agreement. Both routes stay open.
Will the product cope if usage grows suddenly?
We build on cloud infrastructure that scales horizontally and avoid shortcuts that make scaling painful later. We do not, however, engineer for enterprise-scale load at this stage, because that spends time and budget before the need is proven. As load approaches the limits, we handle it as a planned phase based on measured behaviour.