02
Development
Web Application Development
Portals, dashboards and multi-tenant platforms that run in any browser: fast, accessible and secure, on code and hosting you own.
From$3,000
Software Development · Service 05
MVP & Digital Product Development
The smallest real product that tests your riskiest assumption, with accounts, payments and analytics in place, on code that can grow if it works.
Starting from
$3,200
- Discipline
- Software Development
- Shortest timeline
- 2 to 4 weeks
- Clients
- Businesses, organizations & founders
- Delivery
- Remote, worldwide
What this service is
An MVP isn't a cheaper version of your full product. It's the smallest thing you can put in front of real users that answers the question your business depends on.
MVP development starts with a question, not a feature list. Will people sign up? Will they pay? Will they come back next week? We work with you to find the assumption that would sink the idea if it's wrong, then scope the smallest release that tests it with real users. Expect it to be much smaller than your first wishlist. That's the point.
Small doesn't mean flimsy. Accounts, payments and analytics are in place from the first release, so you learn from real behavior instead of opinions. An automated release pipeline lets you ship improvements as soon as they're ready. And the architecture is chosen so that if the idea works, you build on what you have instead of paying for a rewrite at the worst possible moment.
Problems we solve
The situations that bring people to us
These are the moments an MVP engagement is designed for.
The situation todayWhat changes
You have a long feature list and no clear sense of which part matters most
A ranked scope built around the one question the first release has to answer
You're about to spend most of your budget on a full build nobody has tried yet
A clickable prototype tested with target users before development starts
Your first version found users, but now every change breaks something else
A clean foundation where growth means adding to the product, not rewriting it
You can't tell whether people are activating, coming back or quietly leaving
Product analytics on the events that matter, tracked from the first day
Taking payments and managing subscriptions feels like a project of its own
Stripe billing, plans, trials and invoices set up as part of the first release
An investor meeting or board review needs something real to show, on a fixed date
A working product and a stable demo environment, delivered against a dated plan
What you get
Deliverables
Not every engagement includes every item. Your proposal lists exactly what's in scope, and what isn't.
-
01
Product discovery and assumption map
Workshops that pin down the target user, the problem they'd pay to solve and the assumptions behind the idea, ranked by how much damage each would do if wrong.
-
02
Release scope and cut list
A written definition of the first release, plus an equally clear list of what's deliberately left out and why, so nothing creeps back in unnoticed.
-
03
Clickable prototype and user testing
A realistic prototype tested in one-to-one sessions with people from your target audience, with findings and design changes written up.
-
04
Accounts, payments and subscriptions
Sign-up, sign-in, teams and roles, with Stripe handling cards, plans, trials, upgrades, refunds and canceled subscriptions.
-
05
Analytics and event tracking
The handful of events that answer your key question (sign-up, activation, retention, conversion) tracked from day one in PostHog, Mixpanel or your preferred tool.
-
06
Release pipeline and environments
Automated tests and deployments, a staging environment and feature flags, so new versions ship often and can be rolled back safely.
-
07
Scaling path
A short written plan covering what was built for now, what will need attention as usage grows and the signs that it's time, so growth is planned rather than an emergency.
-
08
Demo environment and launch support
A stable, seeded environment for investor and stakeholder demos, plus hands-on help through launch day and the first round of feedback.
Visual model
What goes into a first release
How the pieces typically fit together on this kind of engagement.
Early usersInvited or self sign-up
Your teamAdmin and support tools
InvestorsStable demo environment
Core user journeyThe one flow that tests your idea
AccountsSign-up and roles
PaymentsStripe subscriptions
AnalyticsEvents from day one
Feature flagsSafe experiments
Release pipelineTested, deployed and reversible
Room to growScales up without a rewrite
Common use cases
Where this work usually applies
Practical patterns rather than industry labels. The shape of the problem matters more than the sector.
-
Use case 01
Two-sided marketplaces
Listings, search, messaging and payouts between buyers and sellers, launched in one city or niche before expanding.
-
Use case 02
Niche SaaS products
A focused tool for one type of customer, with self-serve sign-up, a free trial and paid plans from the first release.
-
Use case 03
Internal ventures and spin-offs
A new digital product from an established company, tested with real customers outside the core business before a larger investment.
-
Use case 04
Services turned into software
A consulting method, spreadsheet model or manual service rebuilt as a product customers can use without you in the room.
-
Use case 05
Community and membership products
Profiles, gated content, events and paid tiers for an audience you've already started to build.
-
Use case 06
Pilots and proofs of concept
A working version for a pilot customer, partner or grant milestone, built so it can be extended once the pilot makes its case.
Our approach
How we handle this kind of work
The parts of our method that matter most for mvp & product.
- 01
Test the riskiest assumption first
A product can be well built and still wanted by nobody. We look for evidence of demand and willingness to pay before polishing anything.
- 02
Cut scope, not quality
Three features that work reliably beat ten that only half work. Everything left out goes on a written list with a reason beside it.
- 03
Prototype before writing code
Putting a clickable prototype in front of target users finds confusing screens and missing steps while changes cost hours, not sprints.
- 04
Measure from the first user
Analytics, error tracking and a feedback channel ship with the first release, because launch day is when the real learning starts.
- 05
Build for the next stage, not the final one
A mainstream, well-supported stack and a clean structure let the product grow without a rewrite. We won't over-engineer for scale you don't have yet.
Project stages
From first conversation to delivery
Each stage has a defined output and a review point, so you always know where the work stands.
How our process works-
01
Frame
Workshops on the target user, the problem and the business model, ending in the one assumption the first release must test.
-
02
Prototype
A clickable prototype put in front of target users and revised until the core journey makes sense without explanation.
-
03
Scope
A written release scope, a cut list, a technical plan and a fixed quote with a dated schedule.
-
04
Build
Weekly iterations with a working preview link, so you watch the product take shape and adjust priorities as you learn.
-
05
Launch
Production setup, payments switched to live mode, analytics verified and a planned release to your first users.
-
06
Learn
Regular reviews of usage data and feedback, small releases that act on it, and a clear decision about what to build next.
Capabilities
What we bring to this work
Only the capabilities that matter for this service, and nothing we wouldn't actually recommend.
Product
- Discovery workshops
- Assumption mapping and scoping
- Clickable prototypes in Figma
- One-to-one user testing
- Onboarding and activation flows
- Post-launch roadmaps
Foundations
- Accounts, teams and roles
- Stripe payments and subscriptions
- Product analytics and event tracking
- Transactional email
- Admin and support tools
- Feature flags and staged rollouts
Engineering
- Web apps and progressive web apps
- Mainstream, well-supported stacks
- CI/CD and preview environments
- Error tracking and logging
- Cloud hosting in your name
- Architecture notes and a scaling plan
Delivery and engagement
Typical timelines
Timelines depend on how much discovery is needed, the number of user types, payments and integrations, and how quickly test users can be recruited and feedback given. Every proposal includes a dated schedule, and if a deadline means cutting scope, we'll say so early.
Clickable prototype with user testing2 to 4 weeks
Focused MVP, first release6 to 12 weeks
MVP with subscriptions, admin tools and integrations3 to 5 months, with early releases along the way
Who it's for
Typical clients for this work
We work with companies, organizations and individuals. The requirement matters more than the size of the buyer.
Founders and startups
- Non-technical founders who need a product partner, not just developers
- Pre-seed and seed teams preparing to raise
- Technical founders who want a first release out faster
- Founders whose first version can't grow any further
Established companies
- Internal ventures testing a new digital product
- Teams turning a service or internal tool into something they can sell
- Strategy teams that need evidence before committing a bigger budget
Organizations and individuals
- Nonprofits and social enterprises piloting a digital service
- Experts and creators turning what they know into a paid product
Related services
Often commissioned alongside this
09
Consulting
Software Architecture & Technical Consulting
Independent architecture and code reviews, technical due diligence and design advice, so big technical decisions rest on evidence, not habit.
From$2,200
07
Consulting
IT Consulting & Technology Strategy
Independent, vendor-neutral advice on what to build, buy, keep or retire, turned into a roadmap and budget your leadership team can act on.
From$1,900
Service FAQ
Questions about mvp & product
How small should an MVP be?
Smaller than feels comfortable. It should do one job well enough that target users would be disappointed if it disappeared, and nothing more. If a landing page, a manually run service or a no-code tool can answer your question faster and cheaper, we'll recommend that before writing any code.
Will we have to rebuild it if it takes off?
That's what we design against. We use mainstream frameworks, a clean data model and hosting that scales, and we write down what will need attention as usage grows. Some parts will be reworked at higher volumes, which is normal, but you'll be extending the product rather than starting over.
Do we own the code?
Yes. Code, designs, domain, hosting, analytics and Stripe accounts are set up in your company's name from the start. That keeps ownership clear for investors and acquirers, and lets you bring development in-house whenever you're ready.
Can you help us prepare for an investor demo?
Yes. We'll plan releases around your date, prepare a stable demo environment with realistic sample data, and rehearse the walkthrough with you. We won't fake features that don't exist, because a demo that can't survive due diligence does more harm than good.
What does the $3,200 starting price cover?
Either a prototype-and-testing phase or a tightly scoped first release: one core user journey, standard sign-up, a simple admin view and analytics on the key events. Subscriptions, marketplaces, native mobile apps and integrations add to the scope. You'll get a fixed quote against a written scope, along with a clear view of what could be cut if budget is tight.
Starting from
$3,200
Final pricing depends on how much discovery is needed, the number of user types, payments and subscriptions, and integrations. You'll receive a fixed quote against a written scope before any commitment.
Have a project in mind?
Tell us what you're trying to achieve. We'll come back with a clear view of the scope, the approach and the cost, and if we're not the right fit, we'll say so quickly.