Buy a game prototype when you need a playable answer faster than you can produce one yourself — a pitch deadline, a genre you'll never reuse, a team with more ideas than hands. Build it in-house when the prototype is the first room of the game you'll keep living in, because the skills and the code carry forward. In November 2026 the buy side spans three real tiers: $150–$500 freelance gigs, $4,000–$15,000 offshore studio builds, and $25,000–$50,000 for the same brief at a US agency — while the build side runs on tools that cost less than a single day of studio time.
A transparency note before the numbers: Egmatic is a pre-alpha AI-native game-building tool, and this blog is how we think through the decisions indie developers actually face. We are not a prototyping service, we don't take client work, and we have no stake in whether you hire one. We do have a stake in you getting a playable answer to "is the core fun?" quickly and without surrendering your idea. Every price below was checked against a live page, with its source and date named — vendor-published pricing guides are labeled as such, because they have a reason to make hiring look good.
This article is about the buy-versus-build decision and, if you buy, how to do it without losing your IP or your budget. It deliberately skips two neighboring questions. Which tool to build with is a separate one — the prototyping tools by use case guide covers that. The hour-by-hour execution of a fast in-house build is its own tutorial. And if you're still upstream of prototyping entirely, deciding between engines, start with how to choose a 2D game engine.
Quick answer
The decision turns on two questions, not one. First: is the prototype a disposable answer or the start of production? Second: does your team already have the skill the build needs? Buy when you need a disposable answer and lack the skill or the calendar time. Build when the prototype becomes v0.1 of the real game, or when learning the tool is itself part of the point.
| Your situation | Route | Typical cost (Nov 2026) | What you keep |
|---|---|---|---|
| One mechanic to validate fast, no reuse expected | Freelance gig | $150–$500, 1–4 weeks | A playable answer; usually throwaway code |
| Pitch or investor demo on a deadline | Offshore studio, fixed quote | $4,000–$15,000 | A presentable build, source on delivery |
| Publisher-grade vertical slice, no internal team | US agency | $25,000–$50,000 | Production-quality slice and a relationship |
| Prototype is v0.1 of the game you'll ship | In-house | $0–$130/yr in tools + your evenings | The skill, the code, the momentum |
The bottom row is the one solo developers underrate. A prototype built by someone else answers one question once. A prototype you built yourself is the first commit of your game plus a skill you'll reuse every future weekend — and at hobby scale, the tool bill is nearly zero.
What game prototyping services actually charge
The market is three tiers, not one, and mixing them up is the most common budgeting error. The figures below were checked in November 2026; sources are named with each.
| Tier | What it costs | What you get | Source, checked |
|---|---|---|---|
| Freelance gigs | $150–$500 typical, $176 average fixed; hourly $15–$57 | Core mechanic, placeholder assets, simple UI, playable demo in 1–4 weeks | Fiverr marketplace cost guide, published April 2026 |
| Offshore studio | $4,000–$15,000 fixed for a playable prototype | A scoped build with milestones; region rates $25–$60/hr (S/SE Asia) to $40–$80 (E. Europe) | GameTactics pricing guide (vendor), published October 2026 |
| US agency | $25,000–$50,000 for the same brief | Account management, US-hours communication, agency polish on the same scope | GameTactics pricing guide (vendor), published October 2026 |
Three numbers inside that table deserve attention.
The gap between tiers is scope and risk, not talent. The same single-mechanic brief prices at $176 on a gig platform and at $4,000+ at a studio because the studio carries a team, a schedule, and accountability for the build actually working. Fiverr's own guide notes that prototype phases typically cost 10–20% of the eventual full development budget — the prototype is the cheap part of whichever route you take.
Scope is the lever that actually moves quotes. The October 2026 GameTactics guide describes a brief cut from twenty interlocking systems down to six retention drivers — and the quote halved. A one-mechanic hyper-casual MVP (one core loop, 20–30 levels) is a 4–8 week job at a small studio. If a quote shocks you, the fix is rarely negotiation; it's cutting the brief until the price fits the question you're answering.
Rush and ambiguity are the two multipliers. Compressing a four-week prototype into two adds 50–100% at the gig tier, per Fiverr's guide. And a scope you can't articulate yet is what paid discovery is for — a $2,000–$10,000 phase where the studio turns "something like Vampire Survivors but calmer" into a written spec, before anyone commits to a build number. Paying for discovery on an ambiguous idea is cheaper than paying for a build of the wrong thing.
What the in-house route really costs
The cash cost is almost comically small next to the buy side. As of 2026: Godot is free, GDevelop starts at €4.99/month for its Silver tier, and Construct 3's Individual plan is $129.99/year. Even the "expensive" option rounds to zero against a single studio invoice.
The real costs are elsewhere. Time: a simple 2D core loop runs 40–80 hours of work at mid-tier speed — Fiverr's guide uses exactly that arithmetic for its pricing ranges, and it holds whether you pay someone or spend the hours yourself. The first-prototype tax: your first build in any tool takes multiples of your tenth, so the honest in-house estimate for a beginner isn't the tutorial's four hours, it's that plus a week of learning the editor. Game jams are the existence proof that experienced hands compress a playable core loop into a weekend — the build-a-prototype-in-hours tutorial documents that workflow hour by hour, and the tool-by-use-case guide exists precisely to cut the tool-choosing tax.
What in-house buys you that no service sells: iteration speed after the first build. When playtesters say "the jump feels wrong" on Friday, in-house means a fix and a new build Saturday morning. Outsourced means a change request, a quote, and next week. If you expect to iterate ten times — and validating a mechanic usually takes ten times — the calendar cost of outsourcing compounds past its price advantage fast.
The honest comparison
| Dimension | Outsourced | In-house |
|---|---|---|
| Time to first playable | Days to weeks, runs in parallel with your life | Days to weeks, but they're your days and weeks |
| Cash cost | $150–$50,000 by tier | ~$0–$130/year in tools |
| Cost per iteration | Every change is a change request | Minutes to hours |
| What you learn | How to write a brief and manage a vendor | How to build the game you'll ship |
| Control and IP | Yours only if the contract says so, before work starts | Yours by default |
| Failure mode | A polished build of the wrong mechanic | An endless prototype that never faces players |
Both failure modes in the last row are real, and they're mirror images. The outsourcing failure is paying for polish before the idea deserves it — a beautiful build of a mechanic that isn't fun. The in-house failure is prototyping as procrastination: perfecting a greybox for three months because building feels safer than showing it to anyone. The discipline that prevents both is the same, and it isn't a purchasing decision: set a kill criterion before you start, in the mechanics-validation playbook.
When to buy, when to build
Buy the prototype when:
- There's a hard external deadline — a publisher meeting, a funding application, a conference — and your own learning curve can't fit inside it.
- The build needs a skill your team will use once and never again: a 3D cinematic slice, a physics simulation, an AR proof of concept.
- You're testing whether a concept justifies production at all, and a $176 gig answers that question for less than a week of your time.
- The team's time is genuinely more expensive than the invoice — the founder-consultant arithmetic where 40 hours of your billed work exceeds the studio quote.
Build in-house when:
- The prototype is v0.1 of the game you intend to finish — you want the code and the commits, not just the answer.
- You'll iterate more than twice; every iteration after the first is where in-house speed wins.
- Learning the tool is part of the goal, not overhead — the skill compounds across every future project.
- The idea is still soft. If the design itself will change under your hands while building, you don't want to be paying $85/hour to discover it.
The honest summary: solo developers with more time than money should almost always build the first prototype themselves, and teams with a deadline and a clear one-off scope should almost always buy. The expensive mistakes happen in the middle, from choosing by price tier instead of by question.
How to buy without getting burned
The process matters more than the vendor. This sequence follows the October 2026 GameTactics guide's contract norms and red-flag list, plus the Fiverr guide's scoping arithmetic.
- Write a two-page brief before contacting anyone. One mechanic, described as a loop ("the player dashes, collects, dodges; the pace rises"). Deliverables: a playable build, the source, and a 60-second capture. Anything you can't fit in two pages is production, not prototyping.
- Cut the brief to six systems maximum. This is the lever that halves quotes — the twenty-systems-to-six cut in the GameTactics guide halved the price of a real brief. If a system doesn't test the core question, it's not in the prototype.
- Ask for milestones, not a total. A quote that is one number with no schedule is the first red flag. Normal structure: 20–30% deposit against the first milestone, then payments against delivered builds — weekly or biweekly.
- Put IP assignment on delivery, in writing, before work starts. "You'll own it when we're fully paid" means you don't own it when you need it. Assignment on milestone delivery, in the signed contract, is the norm the guide's red-flag list treats as table stakes.
- Vet the studio like a hire. Named team members, shipped store links, and a working prototype they'll let you play. No named humans and no playable references is red flag number three.
- Cap hourly work. If the engagement is hourly, the contract needs a not-to-exceed number and a fixed build cadence — hourly with no cap and no weekly build is how a $6,000 prototype becomes a $20,000 prototype.
- For fuzzy scope, buy discovery first. $2,000–$10,000 to turn a vibe into a spec, then quote the build. Any studio willing to quote a build on "you know, a survival thing" is pricing your confusion, not your game.
Five mistakes worth avoiding
Budgeting the gig tier for studio work. The $176 average is for one mechanic and placeholder art. Expecting a gig to deliver a multi-system, polished, portable build buys disappointment and burns a seller who priced an honest brief.
Buying before you can evaluate a build. If you can't tell whether the core loop in front of you is fun, outsourcing just moves the ignorance onto an invoice. Run the validation playbook first; buy the build second.
Spec inflation by prestige. Moving from a $6,000 offshore quote to a $40,000 agency quote for the same brief buys communication comfort and polish, not a better answer to "is this mechanic fun?" Pay for the answer you need, not the logo on the invoice.
Treating the deliverable as production code. A bought prototype is a decision instrument. Even a good one carries shortcuts — hardcoded values, no save system, throwaway architecture — that make retrofitting it into your shipped game more expensive than rebuilding clean. Plan on keeping the answer, not the codebase.
No kill criterion on either path. The point of a prototype — bought or built — is to make a cheap decision. Without a pre-written standard for "this mechanic is dead," both routes drift toward sunk-cost production. Write the criterion before the first invoice or the first commit.
Where Egmatic fits
Notice what both routes in this article assume: that "in-house" means you learning an engine, and that "buying" means handing your idea to strangers. A solo developer with a day job is choosing between months of evenings and a leap of trust — that's a real gap in the market, and it's the gap we're building into.
The frame we're committing to, stated plainly: you direct, it executes, you own it. Design decisions stay yours — what the mechanic is, what changes, what ships. The AI teammate does the build work under that direction, and every exported file is yours, with no lock-in and no "IP on final payment" games because there's nothing to withhold. We're pre-alpha and we say so; early access today means build news a few times a year, not promises of magic. But the direction is precisely the middle path this article maps: the speed of buying with the control of building.
If that's the path you want to watch mature:
Fact-check notes
Checked November 18, 2026, against live pages:
- Freelance-tier pricing ($150–$500 typical prototype, $176 average fixed, $15–$57/hr, 1–4 week timelines, 40–80 hours for a simple 2D build, 50–100% rush premium, prototypes at 10–20% of full budget): Fiverr's Unity developer cost guide, fiverr.com/resources/guides/costs/unity-developer, published April 2026, fetched live November 18, 2026. Marketplace data, published by the platform itself.
- Studio-tier pricing ($4,000–$15,000 offshore prototype, $25,000–$50,000 US agency, regional rates $25–$60 through $100–$200/hr, 15–30% fixed-quote buffer, $2,000–$10,000 paid discovery, 4–8 week small-MVP scope, contract norms and the red-flag list): GameTactics, "The Real Cost to Hire a Game Development Company in 2026," published October 12, 2026, gametactics.io/blog/cost-to-hire-a-game-development-company, fetched live November 18, 2026. This is a vendor-published guide — an outsourcing company's own pricing content — and is attributed as such in the text; its figures are used as market reference points, not as neutral data.
- In-house tool costs (Godot free, GDevelop Silver €4.99/month, Construct 3 Individual $129.99/year): verified against the vendors' live pricing pages earlier in 2026 as part of our engine-coverage work; consistent with the prototyping tools guide and the engine choice guide.
- The twenty-systems-to-six scope cut halving a real quote: the GameTactics guide's own worked example, October 2026.
- The pay-per-prototype era context (prototype builds once priced at $1,500–$2,500 in hyper-casual publisher deals) was checked but deliberately not used: the source (Azur Games, February 2022) is four years stale for pricing purposes and its market has since shifted.
- The decision framework, comparison table, and failure-mode analysis are editorial synthesis — our own — built on the sourced prices above; they are labeled as synthesis where they appear.