# Prototype and pilot sprint for startups: prove one thing first

URL: https://pixelactstudio.com/services/pilot-sprints

> Prototype and pilot sprint for startups: a fixed-price clickable prototype, technical proof of concept, or automated workflow, tested against agreed criteria.

A prototype and pilot sprint is a short, fixed-price project that proves one thing before a startup commits to a full build: a clickable prototype, a technical proof of concept, or one automated workflow. Pixelact agrees pass criteria with you first, tests against them, and recommends whether to build, change direction, or stop. Prices start at $4,500 per pilot.

- Price: From $4,500
- Model: Fixed price
- Timeline: Short and fixed, with the end date set in the proposal

## Who it is for

- We have a funded plan, and we want proof the risky part works before we commit to the full build.
- We need something people can click through before we spend months building it.
- We are not sure the integration our product depends on can do what we need.
- We want an AI feature, and nobody knows yet whether it is accurate enough on our own data.
- One manual process eats hours every week, and we want to see it automated before we automate the rest.

## What you get

- **Pilot brief:** One page agreed before any build starts: the question, the pass criteria, and which result means build, change direction, or stop.
- **The working pilot:** A clickable prototype, a technical proof of concept, or one automated workflow, built in your repository or your design files.
- **Test results:** What was tested, with which users, data, or inputs, and how the result measured against each pass criterion.
- **Eval set for AI pilots:** Real examples with accepted answers, measured accuracy, failure cases, and cost per run, kept so every later change can be scored the same way.
- **Written readout:** Our recommendation, the risks still open, and what a build would involve if you go ahead.
- **Walkthrough call:** A live review of the results with everyone who decides, so the next step rests on evidence rather than opinion.

## How it works

1. **Discovery call.** A 45-minute call about what prompted this now, where things stand, and what a good outcome looks like. No slides, and no solution before we understand the problem.
2. **Proposal walkthrough.** Within 48 hours we present the proposal live: the question, pass criteria, scope, exclusions, milestones, two or three options, payment plans, and AI limits where AI is involved.
3. **Kickoff.** Once the deposit arrives, we set up the repository and accounts in your name, collect data and access, and introduce the named lead for your pilot.
4. **Build to the question.** We build only what the question needs, and you see working progress at each milestone in the proposal.
5. **Test against the criteria.** The prototype goes in front of users, the proof runs on real or representative data, or the workflow runs on live inputs. We record what happened.
6. **Readout and handover.** We walk you through the result and our recommendation. Code and final files transfer once the final invoice is paid.

## Not included

- Production launch, load testing, and full security hardening. Those belong to the build that follows.
- A second question. Each pilot proves one thing, and a new question becomes a new pilot or part of the build.
- Recruiting test participants or running a formal user research study.
- Third-party costs such as model usage, APIs, and hosting, which run on accounts in your name.
- Support or maintenance after the readout. Retainers are offered once a build proves its value.

## What does a prototype and pilot sprint cover?

A prototype and pilot sprint answers one question with working evidence, at a fixed price, before you fund a bigger build. Each pilot is one of three types, chosen by the risk you most need to retire: a clickable prototype, technical proof of concept development, or one automated workflow.

**The three kinds of pilot sprint**

| Pilot type | The question it answers | What you get | Example question |
| --- | --- | --- | --- |
| Clickable prototype | Will users understand this flow and want it? | A Figma prototype, or a thin coded front end on sample data | Can a finance lead approve a batch of supplier invoices without training? |
| Technical proof of concept | Can the hard part work at the speed, accuracy, or cost the product needs? | Working code in your repository, run against real or representative data | Can we sync 50,000 CRM records into Postgres each night within the API rate limits? |
| One automated workflow | Does automating this process save the time we think it will? | One workflow on real inputs, with human review where mistakes are costly | Can inbound order emails become draft orders in the ERP without retyping? |

A pilot is not a small MVP. It skips what the question does not need, such as billing, a full permission model, or polish on screens nobody will test. Our guide to [prototypes, pilots, and MVPs](https://pixelactstudio.com/blog/prototype-vs-pilot-vs-mvp) explains where each fits.

## How do you choose what the pilot should prove?

Pick the assumption that would end the plan if it were wrong, and that you can test now for a fraction of the build cost. We work through it with you on the discovery call, and the proposal writes it down.

1. **Name the decision.** Say what the result will decide and who decides: funding the build, signing a design partner, or replacing a manual process.
2. **List the assumptions.** Users want it, the data exists, the integration allows it, the model is accurate enough, and the cost per use fits the price.
3. **Pick the riskiest one.** Choose the assumption most likely to be wrong and most expensive to discover late.
4. **Match the pilot type.** Users in doubt: a clickable prototype. Feasibility in doubt: a technical proof. Operational value in doubt: one automated workflow.
5. **Write the pass criteria.** Turn the question into a result you can observe or count, agreed before the build starts.
6. **Agree the decision rule.** Decide in advance which result means build, which means change direction, and which means stop.

> **What good pass criteria look like.** Weak: “the AI works well on our documents.” Strong: “on 60 sample contracts, the pilot extracts the 12 required fields, sends no more than 1 field in 10 to human review, and the reviewer finds no error it failed to flag.” The second one can only pass or fail, and the review cap stops the system from passing by flagging everything.

## Why do AI systems always start with a pilot?

An AI feature is only as good as its results on your data, so nobody can promise accuracy before testing it there. Every [AI system](https://pixelactstudio.com/services/ai-systems) we build starts with a pilot that settles five things:

- **An eval set**: real examples paired with the answers you would accept, which every later prompt or model change must pass.
- **Accuracy on your data**: how often the system is right, and how it fails when it is wrong.
- **Cost and latency per run**: measured on real examples, with cost projected to your expected volume, so unit economics are known early.
- **Where human review sits**: which outputs go straight through and which wait for a person.
- **Data boundaries**: what the model may see, what it must never see, and where data is processed.

For [AI search over company knowledge](https://pixelactstudio.com/blog/ai-search-over-company-knowledge), built with retrieval-augmented generation (RAG), the pilot also scores retrieval on its own: does the right passage come back for each question in the eval set? A fluent answer built on the wrong document is still wrong. The [AI feature readiness checklist](https://pixelactstudio.com/resources/ai-feature-readiness-checklist) covers what to have ready.

## What happens after the pilot?

Every pilot project ends with a readout and a written recommendation: build, change direction, or stop. The decision stays yours.

### Build

The result feeds a build proposal, priced by milestone, for [product development](https://pixelactstudio.com/services/product-development), [internal tools](https://pixelactstudio.com/services/internal-tools), or an AI system. Code from a technical proof or workflow can carry forward, because it follows our [engineering standards](https://pixelactstudio.com/about/engineering-standards): written in your repository, reviewed, and tested on the part it proved. The readout says what to keep and what to rewrite.

### Change direction

Sometimes a pilot proves one part of the plan and breaks another, such as an integration that works only on a higher API tier. We rescope with you, and the next step may be a second pilot or a smaller build.

### Stop

If the riskiest assumption fails, stopping is the cheapest good outcome. You learn it at a fixed price instead of halfway through a build, and the code, findings, and test data are yours to reuse.

## How much does a pilot sprint cost?

Pilot sprints have a fixed price that starts at $4,500 and is set in the proposal once the question and pass criteria are clear. If the budget is tight, we cut scope rather than discount the same work.

- **Payment**: each quote offers two or three plans, such as 100% upfront with 5% off, or 50% at the start and 50% on delivery. Work starts once the deposit arrives.
- **Third-party costs**: model usage, APIs, and hosting run on accounts in your name, and you pay the providers directly, so nothing is marked up.
- **Ownership**: the repository and accounts are yours from day one, and code and final files transfer once the final invoice is paid.

## What should you prepare for a pilot sprint?

Bring the decision the pilot feeds and the assumption you doubt most, plus access to whatever the test needs. The proposal is built from these:

- The decision the pilot result feeds, and the person who makes it.
- The one assumption you are least sure of, written as a single sentence.
- Sample data, documents, or test accounts, redacted where needed.
- Sandbox access to any third-party system involved, such as a CRM, ERP, or payment provider.
- For a clickable prototype, a few target users who will try it and talk through what they see.
- A named person on your side who gives feedback and approves the result.

If the question is still a whole product plan rather than one assumption, the [MVP readiness checklist](https://pixelactstudio.com/resources/mvp-readiness-checklist) helps narrow it down.

## How does a pilot sprint compare with an audit, a design sprint, or an MVP?

Each option answers a different question. A pilot sprint fits when one risk stands between you and the build.

**Pilot sprint compared with common alternatives**

| Option | Best when | What you get | Pricing |
| --- | --- | --- | --- |
| Pilot sprint | One assumption decides whether a bigger build is worth it | A prototype, proof, or workflow tested against agreed criteria, plus a recommendation | Fixed price, from $4,500 |
| [Software audit](https://pixelactstudio.com/services/software-audits) | You have code or a plan and need to know its risks | A written report that ranks risks and fixes, with a build path and rough costs | Fixed fee, from $2,500 |
| Design sprint workshop | A team needs to agree on a direction and test it with users | A prototype tested with customers and a team aligned on it, with no answer on feasibility | Varies by provider |
| MVP build | The main risks are retired and you are ready for real users | A first production version | Priced by milestone |
| Prototyping with AI coding tools | You want to see an idea on screen today | A fast first draft and a sensible place to start, with pass criteria, testing, and review left to you | Your own time and tool costs |

## Frequently asked questions

### How long does a pilot sprint take?

A pilot sprint is short by design, and its end date is written into the proposal before work starts. The date depends on the pilot type and on how fast access arrives. Sandbox credentials, sample data, and time with test users are the usual causes of delay, so we ask for them at kickoff. If the scope keeps growing, the extra question becomes a second pilot.

### What is the difference between a prototype, a proof of concept, and a pilot?

A prototype tests whether users understand and want a flow. A proof of concept tests whether the hard technical part can work. A pilot puts a working piece into real conditions at a small scope, such as one automated workflow on live inputs. Our pilot sprint covers all three, because each one proves a single thing before a bigger build. Our [prototype vs proof of concept vs MVP comparison](https://pixelactstudio.com/blog/prototype-vs-pilot-vs-mvp) shows where each fits.

### What makes a pilot sprint cost more than $4,500?

The price follows the work the question needs. More integrations, harder access to data, deeper AI work such as a larger eval set, more interface for users to test, and a tight deadline all move a quote up. Slow feedback does too, because it stretches the sprint. When a quote lands above budget, the usual fix is a narrower question, such as one integration instead of three.

### Can the pilot code be reused in the full build?

Often, in part. A technical proof or workflow usually keeps its core logic, such as the sync job or the extraction step, and the build adds what production needs around it: sign-in and permissions, retries and error handling, monitoring, and tests beyond the part the pilot proved. A clickable prototype is a design artifact. It becomes the brief for production screens, not the first version of their code.

### What happens if the pilot fails its criteria?

The readout separates two kinds of failure. If the assumption itself was wrong, such as users not wanting the flow, the recommendation is usually to stop or change the plan. If the approach fell short, such as a model or data source that missed the bar, it names what could change the result and whether that is worth a second pilot. Either way, you have no obligation to continue with us.

### Can a pilot run on our real customer data?

Yes, within limits agreed in the proposal. The data boundary sets which records the pilot may use, what must be redacted, and which providers may process it. Model and API calls run on accounts in your name, so you control provider settings such as data retention. When real records are too sensitive, we test on representative data, and the readout says so, because results can shift on live data.

### Is a pilot sprint the same as a design sprint?

No. [GV's design sprint](https://www.gv.com/sprint/) is a five-day process that ends with customer interviews on a prototype built as a realistic façade, so it shows how people react but not whether the product can be built. A pilot sprint can produce a clickable prototype too, but it can also prove a technical risk or automate a real workflow, and it ends with a written recommendation.

### Should we start with an audit or a pilot?

Start with an audit when you already have a product or codebase and need to know what is risky in it. Start with a pilot when the plan is clear and one open question about something new decides the build. If you are adding a risky feature to existing code, an audit first often makes the pilot sharper.