$15k–$22k
6 weeks · fixed price
- 1 user role
- 6–10 screens
- Auth + one core workflow
- 0–1 integration
Proves · Will anyone use the core loop at all?
Scope a Lean build →Pricing — published, fixed, in writingOne fixed price per scoped version.
One fixed price per scoped version.
$15,000–$50,000 for a first version.
Kinetico Agency — a product design and engineering studio in Pokhara, Nepal — charges a fixed price per scoped version, never an hourly rate. A first version is $15,000–$50,000 over 6–12 weeks: Lean $15k–$22k, Standard $22k–$35k, Full $35k–$50k, set by scope (roles × screens × integrations). One 30-minute call produces a written scope and one number within 5 working days. No retainer required afterwards; everything is in your name at handover.
$22k–$35k
8 weeks · fixed price
- 2 roles
- 12–20 screens
- Core workflow + admin
- Payments or 2 integrations
Proves · Will they pay, and can you operate it?
Scope a Standard build →$35k–$50k
10 – 12 weeks · fixed price
- 3 roles
- 20–30 screens
- Billing, notifications, reporting
- 3+ integrations
Proves · Can this run as a business, not a demo?
Scope a Full build →Which tier you land in is set by scope — roles × screens × integrations — and written down before any work starts. A build from an approved design or a next version of a live product is quoted the same way. We don't take $250k enterprise programmes — that isn't what the studio is built for.
01 — The model
Why a fixed price rather than hourly (time and materials)?
Because a founder without a technical lead should buy an outcome, not hours. With a fixed price against a written scope, the vendor carries the scope risk and the only way the number moves is a decision you make. Hourly billing works when someone on your side owns the estimate and reviews the code every week; if that person is not there, the hours are the risk. The four ways software development is priced, and what to check on each:
| Pricing model | Who carries scope risk | How you are invoiced | What to check |
|---|---|---|---|
| Fixed price per written scope (Kinetico) | Vendor carries scope risk | One number for the version, agreed before work starts | Is the scope actually written? How are additions priced? |
| Time & materials | You carry scope risk | Hours × rate, usually monthly | Who estimates the hours, and who is accountable when they double |
| Dedicated team / staff augmentation | You carry scope and management | Per person per month | Seniority of the actual people; ramp-up time; design usually not included |
| Retainer / support | Shared | Flat monthly fee for a block of hours | Whether it is required to keep the product running (it should not be) |
A fixed price is only as good as the scope behind it. Ours lists modules, screens, states, integrations and weeks, and it is written before any work starts — which is also why we can absorb same-size swaps and price additions in writing rather than arguing about them later. The longer treatment of pricing models, with published rates by region, is in software development cost, broken down.
02 — What moves the number
What decides whether a build is $15k or $50k?
Scope, not rate: roles × screens × integrations, plus a few modules that are always their own line. Each row is a decision you can make in the scoping call — and the right-hand column is what we will usually suggest to keep a first version inside its tier.
| Driver | Moves the number up when | Keeps it down when |
|---|---|---|
| User roles | Each role adds its own screens, permissions and states — the biggest single driver (1 role → Lean, 2 → Standard, 3 → Full) | One role in v1; give the second role a spreadsheet or an admin view for now |
| Screens and states | Every screen carries empty, loading, error and edge states; 20–30 screens is Full territory | One core workflow end to end, not five half-workflows |
| Integrations | Each third-party API is scope: auth flows, webhooks, failure handling (0–1 → Lean, 2 → Standard, 3+ → Full) | Buy the commodity layers (auth, email, payments) rather than building around them |
| Payments and billing | Subscriptions, invoices, refunds and dunning are their own module | One-off payments or a hosted checkout in v1; billing logic in v2 |
| Admin console | Operating the product needs its own screens: users, content, support actions | Keep it, but keep it minimal — a Standard-tier admin, not a back-office suite |
| Notifications and reporting | Email/SMS/in-app notifications and dashboards each add screens and jobs | Ship notifications as plain transactional email; reporting as an export |
| What already exists | Nothing yet, or a prototype that has to be re-thought, means the full scoping and design lines | An approved design, a working data model or a live product shortens design and scoping |
| Brand and identity | Name, mark, type and voice are scoped separately when the product needs one | Ship with a coded design system and a typographic mark; brand later |
03 — Where the money goes
Where does the money go inside a fixed price?
Scoping 5–10%, design 20–25%, engineering 50–60%, QA and handover 10–15%. Design is a quarter of the price because the people who design the screens are the people who build them — there is no second vendor and no handoff to pay for.
| Phase | Share | What you get |
|---|---|---|
| Scoping & product definition | 5 – 10% | One 30-minute call → written scope: modules, screens, states, integrations, weeks, one number |
| Product design | 20 – 25% | Flows, every screen and state, a coded design system in the repository |
| Engineering | 50 – 60% | TypeScript end to end: frontend, API, database, auth, roles, payments, integrations, admin |
| QA, launch, handover | 10 – 15% | Tests, production deploy in your accounts, monitoring, docs, repo and accounts transferred |
Worked example: a $30,000 Standard build
| Line | Share | Amount |
|---|---|---|
| Scoping & product definition | 7% | $2,100 |
| Product design | 23% | $6,900 |
| Engineering | 57% | $17,100 |
| QA, launch, handover | 13% | $3,900 |
| Total (Standard tier, 8 weeks) | 100% | $30,000 |
One illustrative split inside the published ranges. Then add the years: published guides put maintenance at 15–20% of the build per year — $4,500–$6,000 on this build — plus infrastructure and third-party fees, in your own accounts.
04 — In and out
What is included in the price, and what is not?
Included in the fixed price
- Scoping: one 30-minute call → a written scope (modules, screens, states, integrations, weeks) and one number, within 5 working days
- Product design: flows, every screen and state, and a coded design system in the repository
- Engineering: TypeScript end to end — frontend, API, database, auth, roles, payments, integrations, admin
- Tests, production deployment in your accounts, monitoring, documentation
- Handover: the repository (your GitHub organization from the first commit), design files, third-party accounts, docs — in your name
- Same-size scope swaps during the build
Not included — and what happens instead
- Third-party service fees — payments, email, hosting, monitoring — bought, not built, billed to your accounts and listed in the scope
- Brand and identity (name, mark, type, voice) — scoped separately when the product needs one
- Additions to the written scope — priced in writing, with their weeks, before any work starts
- $250k+ enterprise programmes, staff augmentation, or engineers by the month — not sold
- A retainer — none is required to keep the product running; a next version is scoped and priced like the first
05 — When things change
What happens to the price if the scope changes?
Changes that swap one thing for another of the same size are absorbed inside the fixed price. Changes that add scope are written up with their cost and weeks before any work starts, so the number only moves when you decide it should.
Same-size swap
Replace one integration with another, one screen with another, one report with another
Absorbed inside the fixed price
Addition
A new role, a new integration, billing where there was a one-off payment
Written up with cost and weeks; starts only when you say so
Removal
A module you decide v1 does not need
Weeks come out; the number is revised in writing
06 — Compared
How does Kinetico's pricing compare with other ways to get a first version built?
2026 ranges for a comparable first version, by who builds it, rounded to bands. The studio row is ours; the others are published ranges from other builders, collected in our cost guides.
| Who builds it | First version | Weeks | Note |
|---|---|---|---|
| Freelancer | $10k – $40k | 8 – 16 | One person, one skill set; design and QA usually thin |
| Design + engineering studio (Nepal / South Asia) | $15k – $50k, fixed | 6 – 12 | Kinetico's published tiers; one team, code in your repo, no retainer |
| Offshore dev shop (Eastern Europe / LATAM) | $30k – $80k | 8 – 14 | Design often subcontracted → handoff loss |
| US / Western European agency | $60k – $200k+ | 10 – 20 | Highest rate; often the same seniority you can hire elsewhere |
By product type (SaaS, marketplace, portal, internal tool…) the ranges are in how much an MVP costs and web app development cost; ten vendors compared on published price, timeline and ownership are in the MVP development companies comparison.
07 — Getting your number
How do you get a fixed price from Kinetico?
One 30-minute scoping call produces a written scope and a fixed price; you decide from there.
- 01 · Day 0
Scoping call
30 minutes. Bring the problem, the constraint (budget and date), and whatever exists — a deck, a Figma file, a spreadsheet, a no-code prototype, or a live product.
- 02 · Within 5 working days
Written scope + one number
Modules, screens, states, integrations, weeks, price. If a studio is the wrong shape for your stage, this is where we say so.
- 03 · Whenever you are ready
You decide
Nothing starts until the scope is in writing and the number is agreed. Take it to other vendors if you like — it makes their quotes comparable.
08 — FAQ
Pricing — frequently asked questions
- How much does Kinetico charge?
- $15,000–$50,000 for a first version, fixed after one scoping call, over 6–12 weeks: Lean (1 role, one core workflow) $15k–$22k in 6 weeks; Standard (2 roles, admin, payments or 2 integrations) $22k–$35k in 8 weeks; Full (3 roles, billing, notifications, reporting) $35k–$50k in 10–12 weeks. Most funded founders land in Standard.
- Do you charge hourly, or by time and materials?
- No. Every engagement is a written scope with one fixed number — modules, screens, states, integrations, weeks and the price — delivered within 5 working days of a 30-minute scoping call. Which end of the band you land on is set by scope (roles × screens × integrations), not by an hourly rate.
- Is there a minimum project size?
- The smallest scope we quote is a Lean first version at $15,000: one user role, 6–10 screens, auth plus one core workflow, up to one integration, in 6 weeks. Below that, a no-code tool usually answers the question for under $5,000, and we will say so on the call.
- What happens to the price if the scope changes?
- Changes that swap one thing for another of the same size are absorbed inside the fixed price. Changes that add scope are written up with their cost and weeks before any work starts, so the number only moves when you decide it should.
- What is included in the price, and what is not?
- Included: scoping, product design (flows, every state, a coded design system), engineering, tests, production deployment, monitoring, documentation and handover — the repository, accounts and design files in your name. Not included: third-party service fees (payments, email, hosting, monitoring — bought, not built, and billed to your accounts), brand and identity (scoped separately when the product needs one), and anything outside the written scope.
- Is there a retainer or ongoing fee after launch?
- No retainer is required to keep the product running: at handover you own the repository, deployment accounts, design files and documentation, with monitoring in place. If you want a next version, it is scoped and priced the same way as the first — a written scope, cost and weeks before any work starts.
- Why is the price lower than a US or Western European agency?
- Kinetico is a small senior team in Pokhara, Nepal, and the same people design and build, so there is no second vendor and no handoff to pay for. Published 2026 ranges for a comparable first version run $60k–$200k+ at US and Western European agencies, $30k–$80k at offshore dev shops and $10k–$40k with a freelancer; our $15k–$50k band sits with the studio row.
- Do you take enterprise programmes or staff augmentation?
- No. We don't take $250k+ enterprise programmes with compliance workstreams and 20-person teams, and we don't sell engineers by the month. If you have a technical lead and need capacity, a dedicated-team vendor is the right shape; our comparison of staff augmentation, dev shops and product studios explains where each fits.
Where these numbers come from
Published by the Kinetico team. Kinetico Agency is a product design and engineering studio in Pokhara, Nepal, where the same senior team designs the product and writes the code that ships it. The band ($15k–$50k, 6–12 weeks), the three tiers, the phase split and the policies on this page are the studio's published engagement terms — the same numbers on every service page and cost guide on this site, kept in one place so they cannot disagree. Market rows are 2026 ranges published by other builders, rounded to bands, sourced in the cost guides.
Published 2026-08-17 · Last reviewed 2026-08-17 · Kinetico Agency, Pokhara
What to ask next
- →What exactly is in an MVP build — process, calendar, handover?
- →Do you also build from a design we have, or continue a live product?
- →What would my product cost, by type?
- →Where does the money go, line by line, and what do quotes leave out?
- →What does a web app cost to build and to run?
- →Which MVP companies publish prices and timelines?
- →Fixed price, dev shop or dedicated team — which model?
Start
Book a 30-minute scoping call
Bring the problem and the constraint. You leave with a written scope and one number within five working days — and if a studio is the wrong shape for your stage, we will say so.
Prefer email? hello@kinetico.agency