smallbox

Idea to Prototype

From an idea to a working prototype in 4 to 5 weeks.

You know the field, the people and the problem, and you have an idea for software that would help. You don’t need a specification, a technical background or a team. Working out what to build is the first part of the work.

For four to five weeks we work on it together. We think it through and challenge each other’s assumptions, I design the system and build it, and you watch it come online on your own server. At the end you have a working first version of your product: not a mockup, but a real system with a deliberately limited scope, to test, to show, and to keep building.

  • €9,000 fixed, excl. VAT
  • 4 to 5 weeks
  • One client at a time
  • Free until you say yes

About 4 minutes: two founders go through the weeks, from their idea to what they keep.

About 2 minutes: what four to five weeks can build, shown in three examples, and what you keep.

  1. Day 1

    You send your material

    Your idea, notes, documents, a prototype, or access to an existing system.

  2. Days 2 to 3

    I study it

    Similar services, what your idea depends on, and the questions only you can answer.

  3. Day 4

    The free meeting

    An hour or two, usually online, starting from what you sent and from my questions.

  4. Day 5

    The proposal

    In writing: what I will build and how, the strategy, what is still unclear, and the price. You decide.

  5. Your yes

    You pay half

    €4,500. You say yes by paying it, and I start as soon as it arrives.

  1. Week 1

    I start building

    Straight from the proposal. I build and show you, again and again, and we go over it together.

  2. Week 2

    It comes online

    The first version runs at your own address. Open it and try it whenever you like.

  3. Week 3

    It comes together

    I add more, and we refine it together. Most of it is done, and it starts to work as one system.

  4. If needed

    A break

    Time to figure things out, or to wait for something outside, such as a scanner that is not working yet. Meanwhile you can test it as much as you like.

  5. Weeks 4 to 5

    What was missing

    What had to wait, such as the scanner, and what you found in testing.

  6. The last day

    You pay the other half

    €4,500. We go through the system together; the server and the code are already yours.

At the end you have a foundational prototype: a working first version that tests the product idea and establishes a technical foundation for continued development. It is foundational because it is built to evolve, not to be thrown away: we identify what is important, I remove the complexity the system does not need, and I make it flexible where it needs to be.

Who it is for

People with an idea and the knowledge behind it.

What they share is an idea, or a question, that only working software can answer.

A founder without a technical partner

You know the customers and the problem. You need someone who turns that into software, and explains every decision on the way.

A technical founder short on time

You could build it yourself, just not this month. You want someone to own the build, and to argue with about the design.

A company testing an idea

A new product, a new part of an existing one, an internal tool. You want a working experiment outside the daily roadmap, without hiring for it.

Someone who has carried an idea for years

You have thought it through many times. Now you want to see it work, and find out what it really is.

Already have a prototype, perhaps made with an AI tool? Bring it: it shows what you mean faster than a description can, and where to start. I evaluate what is there. Then I refactor it, or rebuild it on a proper foundation and use your prototype as the documentation. Both are completely normal.

Before anything is built

We think it through together.

The first conversations are not a requirements meeting. We explore the idea together, the business as much as the screens: the rules it runs on and what its data really means, how the parts relate and where they pull against each other, and what happens at the edges. We think big first, then decide what to build.

I challenge your assumptions, and you challenge mine.

I don’t arrive with all the answers. You know your field, I know how systems behave, and the answers come out of the conversation. That conversation is engineering and product work in its own right. It starts at the free meeting, and through the weeks it is part of the price.

About 9 minutes: one thought experiment with takeaway coffee cups, from what a system is for down into its software.

How it works

What happens, in more detail.

Each part says what happens, what I need from you, and what you have when it is done. To make it concrete, the pictures follow one example idea: a bike-repair service that comes to the customer.

  1. The free meeting and the proposal.

    At least two days before we meet, send me what you have found out so far: a description, notes, documents, examples you like, a prototype, or access to an existing system. I study it and research similar services: how they work, the problems they have met, and the reasons behind their choices. I come with an initial understanding, suggestions and questions, so the meeting starts with your idea rather than with introductions. We meet for an hour or two, usually online, and clarify what we can. Within a day or two I send you a written proposal, and it is already part of the work: what is still unclear, the strategy, what I will build and how, what I believe should be included, what I need from you, four or five weeks, in one go or in two parts, and what it costs. Then you decide. Until then you have paid nothing. If it is yes, you pay half, €4,500, and I start as soon as it arrives.

    Your part
    Send what you have, meet, and decide on the proposal.
    When it is done
    A written proposal you have said yes to, or an honest answer that the idea does not fit.

    ExampleThe questions on the table

    • Who books first: commuters, families, or companies with bikes for their staff?
    • What happens to Tuesday’s bookings when it rains?
    • How long does a repair really take, and who decides?
    • What would tell you the prototype worked?
  2. I start building.

    I start straight from the proposal. In the first week your server is already running, every change goes online automatically, and the whole infrastructure is in place. Where it helps, I draw the system: its parts, what each one is responsible for, how they connect, and which technology fits, designed for your problem rather than taken from a template. But mostly I build, and I show you what I have, again and again. We go over it together, so what the meeting and the proposal left open is worked out with you as we go. Through the first three weeks we meet at least once a week, and we can talk whenever you need to.

    Your part
    Look at what I show you, question it, and answer what comes up.
    When it is done
    The infrastructure running, and the first parts of your system built and shown to you.

    ExampleThe system, drawn

    Example drawing for the bike-repair prototypeThree surfaces at the top: a booking page for customers, the mechanic’s day on a phone, and an Admin for the owner. All three talk to one backend, where the rules live. Below it, four parts with one job each: bookings, routes, weather and email. Payments are drawn dashed, left for later.Booking pagefor customersMechanic’s dayon a phoneAdminfor the ownerBackendwhere the rules liveBookingsRoutesWeatherEmailPaymentslater
    Each box has one job. The weather check came from the rain question; payments are left out on purpose until people book.
  3. It comes online.

    Usually the Admin comes first, so that we can both see what the system does from the start. In the second week the first version is online at your own address: you can see it, use it, sign in and create accounts. From then on you can open it whenever you like, watch it grow, and keep trying it; while I build, its data may be reset now and then. We keep talking, so the questions that only appear while building are worked out with you, not guessed by me, and at the end of the week we usually go through what is there.

    Your part
    Look at it, try it, and answer questions as they come.
    When it is done
    A first version, running at your own address.

    ExampleOnline in week two

  4. It comes together.

    In the third week I add more, and we work closely together to refine it. This is when you see what you want to change, so we usually talk several times, and the changes go in as we go. Keep trying it the way your users would, and show it to people whose opinion matters to you. By the end of the week most of it is finished, and it starts to work as one system; what is still missing becomes the work of the last stretch. A few days before the end we meet, so that I can round off what we agree: the first three weeks, where the system and its foundation are built, end in something whole.

    Your part
    Use it, show it, and say what you want changed.
    When it is done
    Most of it finished, and working as one system.

    ExampleYour notes, worked through

    • Customers want to see when the mechanic arrives.next
    • Say “repair”, not “job”, everywhere.done
    • Block a whole day when rain is forecast.next
    • Show the price before the booking, not after.done
  5. I build what was missing.

    The last weeks are for what the first three could not include: what had to wait for something outside, such as another company’s access, a provider’s data or a device, and what you found while testing. If it makes sense, they follow straight on; if not, there is a break first, and meanwhile you can test it as much as you like. With a scanner that is not working yet, for example, I build everything up to it first, and it goes in once it works. On the last day we go through the system and its documentation together, I write down what it would take to go further, and you pay the other half. Nothing has to be handed over: the server, the code and the accounts have been yours from the first day.

    Your part
    Help with what the product waits on, and decide which changes matter most.
    When it is done
    A working prototype, and everything needed to keep building it.

    What you keepOn the last day

    • The prototype, running on your server
    • The code, in your own private repository
    • The Admin, to run the system and see what it does
    • The documentation: how it works and why, with CLAUDE.md as the map
    • What would come next, and what it would take

The weeks run in one stretch, or in two parts: the first three, a break, then the rest. A break comes when something the product needs from outside is not ready yet, or when you want to use the first part before the rest. The written proposal says which, and what is built in each part. A wait nobody could plan for splits the weeks the same way.

What you get

A real system, and the reasoning behind it.

Not a mockup, a clickable design or a demo with fake buttons. A prototype here is a working system with a deliberately limited scope: what it has works from end to end, online and in your name.

The ordinary parts of a working system

Included when the idea needs them. They are normal parts of the build, not extras.

  • Sign-up, sign-in by email link, and accounts
  • Roles: who may see and do what
  • Emails that confirm, remind and notify
  • Payments and subscriptions through Stripe
  • Real data, and the rules of your business
  • Connections to other services and their APIs
  • Work that runs on its own: queues and scheduled jobs
  • File uploads, documents and search
  • Whole workflows, every step with a clear state
  • Online from the second week

Not every prototype has all of them, and not every prototype has users and payments. A subscription service might let people sign up, pay through Stripe, receive their emails and use the product. A marketplace might let them list, book, pay and get a confirmation.

An Admin, from the start of the build

Every system I build gets an Admin, usually before the part your customers see. It has two jobs.

Running the system
Users, roles, data, settings and the steps of your business.
Seeing what it does
How people move through the product, from signing up to coming back, with the people and the records behind every number. And underneath, the running of the system: emails, background jobs, and anything that went wrong.

The steps that matter are recorded by the system itself, as part of its design, so the numbers need no separate tracking tool. I use the Admin all through the build to look at the system from every side; you use it to follow along, and you keep it when the weeks are over. What it shows is designed for each project.

ExampleThe Admin while people try it

The reasoning, not only the code

Software usually comes as code alone. This comes with the reasoning behind it, written down: what the system is for, how it is divided and why, the rules of your business, the decisions and the alternatives that were weighed, where things live and how to change them.

CLAUDE.md is the entry point, a map to the rest, written so that Claude or another AI assistant can find its way around your system. You or the next developer can then ask why a decision was made, where a business rule lives, or what a change would affect, and the answer comes from the project’s own documents.

It is how I build, not an extra: the documents grow with the system, so whoever continues it starts from the reasoning instead of guessing it.

ExampleThe repository on the last day

Your part

What I need from you.

Your time

Be there to talk: at least once a week, and above all in the first. Answer questions while it is being built: a prototype that waits for answers falls behind. Try it from the second week on.

What you know

Anything that helps me understand what we are building: your own explanation, your team, documents, examples you like, an existing system or its code. It does not need to be organised. Send it before the free meeting, so I can prepare.

Your accounts

A private GitHub repository, a server (Hetzner by default: simple and inexpensive; another host when there is a reason), a domain, and the services the prototype uses, such as an email provider or Stripe. All in your name. You don’t need to know how to set any of it up: I walk you through it, and you give me access.

That is all. Everything is yours from the first day, so nothing has to move when the weeks are over.

Ideas

The kind of thing that fits in 4 to 5 weeks.

Some examples to start from. Not every prototype has users, logins and payments: it has whatever your idea needs. Yours may look like one of these, mix several, or be something else entirely.

The first version of a product

Sign-up, a subscription and the one feature people would pay for. Enough to put in front of your first customers.

A marketplace or booking platform

People who offer something and people who need it: listings, bookings, payment and a confirmation.

An AI assistant for your own material

Questions in plain words, answered from your documents, manuals or records, with the source shown.

Automation between the tools you use

Orders, emails or documents moving between systems on their own, with a person approving what needs a decision.

An internal system

The process that lives in spreadsheets and inboxes, in one place, with an owner and a status for every case.

A mobile app

For people who work on the move, or customers who should not need a computer to use it.

A new part of an existing product

A new capability built and tried beside the system you already run, without disturbing it.

Data processing

Files, feeds or documents coming in, checked and turned into data you can search and use.

An experiment or a simulation

Built to answer one question, such as whether it can be done at all, before you invest in the rest.

Two more, where the hard part is the meaning, not the screens

A calculation engine

The true cost of a loan, for example: amount, period, interest and fees go in; the repayment schedule, the total cost and how each figure was reached come out. The arithmetic is the easy part. The work is in what each number means, which period it applies to and what should change when an assumption does, written down as rules and tested.

Software for a physical operation

Equipment that is lent out, returned, checked and made ready again, across several places. The system keeps the state of every item and who has it, and has an answer for the day the records and the real world disagree.

The price

One fixed price for the whole four to five weeks.

Priced deliberately, so that a whole engagement, from the first week to the last day, is within reach of a founder or a small company.

€9,000

fixed price, excluding VAT

Included
Every conversation, the design, the building, the testing and the changes it brings, what was missing, the documentation, and the walk-through on the last day. Talking is part of the work, not extra hours.
Payment
Nothing until you say yes to the proposal: the meeting and the proposal are free. Then €4,500 when you say yes, which starts the weeks, and €4,500 on the last day.
Scope
Agreed before the weeks start, in the written proposal: what will be built, what is assumed, what I need from you, and how many weeks.
Changes
Welcome. We refine the prototype as we learn, and priorities can change within the agreed scope and the weeks. Anything new, we decide together: it fits in the weeks, or it becomes a next step. Work that would make the engagement bigger is agreed separately.
Not included
Hosting, the domain, and what outside providers such as an email service or Stripe charge. You pay those directly; a small server costs a few euros a month. Setting those services up and building them in is part of the price.

Questions

Questions before you start.

Do I need to know anything technical?

No. You need to know the problem and the people it is for. I explain each decision in plain words, the drawing of your system is made for you to read, and I walk you through setting up the server and the accounts.

What if my idea is bigger than 4 to 5 weeks?

Most good ideas are. Before the weeks start, we decide which part answers your most important question, and the proposal says that part is what gets built; the rest is written down, so it can come next. Ordinary parts like sign-in, email and payments fit in the weeks. If the prototype needs more, for example an unusually complex integration, the proposal says so, with a longer duration and its price. If it waits on another company, the weeks are split around the wait.

Can you start from what I already have?

Yes. A spreadsheet, a document, a sketch, a prototype made with an AI tool, an existing codebase or a running product are all good starting points. They show me what you mean faster than a description can.

Which technology will you use?

The one that fits the problem. Each architecture is designed for its product, not taken from a template, and the technology follows from it: what the product needs, what you already run, and who will build on it next. My deepest experience is in C# and .NET; Python, TypeScript and others are used when they fit better. If you or your developers have preferences, we decide together, including how the code is organised.

Who owns the result?

You do. The code is in your own private repository, the system runs on your server, and the accounts, the domain and everything made for the project are yours. The services it runs on bill you directly.

What happens after the weeks?

You decide. You can carry on yourself, with your own AI assistant, with a developer you hire, or with me under a new agreement. The repository holds what that takes: the code, how it is deployed, and the documentation of how it works and why. And I am still there for questions: we can arrange a conversation about the architecture, the next steps, or what a new developer wants to know.

Is a prototype a finished product?

No, but it is not a mockup either. It is a real, working system with a deliberately limited scope: what it has works from end to end, with real accounts, data, emails or payments where the idea needs them. What it does not have yet is everything a product grows over time, and what that would take is written down on the last day.

Who you work with

One client at a time.

One client. Four to five weeks of focused work. One week to rest and reset.

For those weeks your project is the only one I work on, and I do the work myself: your idea is not handed on to anyone else. It is intensive work, from understanding your business to the last refinement. After each project I take a week off to rest and reset, before the next one begins.

I use AI tools extensively for the implementation, and I remain responsible for the architecture, the technical decisions, the integration and the verification of the result.

You bring the knowledge of your field; I bring the knowledge of how systems are designed and built. We work out together what the product should become. You keep the system, the reasoning behind it, and the structure and development environment to keep moving forward.

Send me what you have.

Your idea in your own words, and anything that explains it: notes, documents, examples you like, a prototype, code, or access to an existing system. It does not need to be organised; the more you send, the better I can prepare. I read it before we meet and come with observations and questions. The meeting and the written proposal are free, and I tell you honestly whether the idea fits in four to five weeks.

Write to me about your idea

The message opens with five prompts. Answer what you can, and attach what you have.

  1. The idea, in a few sentences
  2. Who would use it first
  3. What the prototype should show
  4. What exists already: documents, examples, a prototype, code
  5. When you would like to start

hello.smallbox@proton.me