Skip to content

How we work

Clarity first,
then code.

We take your idea to a product in three stages: work out the core, test how it is used with a prototype and build the application step by step. After launch we can also take care of hosting and support.

Stage 1

Understand & focus

We understand what you want to achieve and what your users need. Together we structure your idea and define the product core for the first usable version.

First call

We clarify goals, users, risks and how you measure success. Open assumptions get named, not glossed over.

Structuring requirements

What you want to achieve, which problem the product solves and who will use it. This becomes an ordered list instead of a loose collection of wishes.

Defining the product core

Together we work out what belongs in the first usable version and what deliberately comes later. This core later becomes the MVP.

Kick-off, Zoom, 60 minutes

Make premium transfers in Costa Rica bookable online, with fixed prices and no enquiry emails.

Product core, version 1

  • Booking flow with fixed prices
  • Top routes from SJO and LIR
  • Payment and booking confirmation

Deliberately later

  • Customer account
  • Destination pages
  • Partner portal
Product core of Elite Pura Vida Rides after the kick-off. This is what the result of this stage looks like.

Result: a shared goal and a clear focus for your MVP.

Stage 2

Design & validate

We make the key flows and the design tangible in a clickable prototype. With your actual users we check what works. In UX Validation Loops we adapt the prototype and add what is still missing.

Clickable prototype

Within a few days the product core becomes your prototype in the browser, with real flows instead of slides. Every version gets its own link.

Testing with users

You and your actual users click through workflows, navigation and design. Every piece of feedback is linked to the version it refers to.

UX Validation Loops

Based on the feedback we adapt the prototype, add further topics and user journeys and test the changes with users again. As many loops as your project needs.

Open questions, decided together

Whatever is still open comes to you on one list, each question with our recommendation. That way there are no surprises halfway through.

A binding fixed-price quote

We break the project into tasks and estimate each one, based on measured values from our past projects. That becomes a binding fixed-price quote for the agreed scope.

Clickable prototype of the booking flow for Elite Pura Vida Rides
Clickable prototype for Elite Pura Vida Rides, three days after kick-off. Every version and every loop stays available under its own link. The version bar is shown as an example.

Open questions, round 1

  • Do guests need an account?

    Recommendation: no, booking via email confirmation. Account later.

    decided

  • Pay upfront or on site?

    Recommendation: upfront online, free cancellation up to 48 hours before.

    decided

  • Which languages at launch?

    Recommendation: English and Spanish.

    waiting for you

Estimate per task

Booking flow
3 to 4 days
Payment and cancellation
2 to 3 days
Calendar sync
1 to 2 days
Admin for routes and prices
2 to 3 days
Total
8 to 12 days
Example. This is what the decision list and estimate look like that you get at the end of this stage.

Result: flows tested with users, a clear scope and a binding fixed-price quote.

Stage 3

Build & expand

With a Code Prototype we check technical feasibility and key integrations. Then we build on it: in agreed Prototype Loops we extend, test and refine the application up to the MVP you can take to market.

Part 1

Code Prototype

The technical foundation. We turn the core features of the tested prototype into working software and check feasibility, architecture and key integrations.

Part 2, builds on it

Prototype Loops up to the MVP

In agreed expansion steps we add features and workflows on the same codebase, test them and sign them off together with you. How many loops are needed depends on the agreed MVP scope.

A clear description per feature

Before each feature it is settled what your users experience, what is explicitly out of scope and when it is done.

Tests before code

First we write the checks, including for failure cases. An independent review adds what is missing. Then the code is written, AI-assisted with Claude and owned by us. Login, payments and data get an extra approval before we build.

Signed off by people

Every feature is checked and signed off by a person, with a live preview and proof that the tests pass.

Product launch

Once the agreed MVP scope is signed off, the application goes live, in Europe, with your data in Frankfurt (GDPR).

Feature: pay for booking

signed off
What users experience
The guest pays the fixed price by card and gets a confirmation right away.
Out of scope
Vouchers, instalments
Done when
Payment, failure and cancellation work and are confirmed.
Tests
14 of 14 passed
of which failure cases
6
Extra approval
Payments
Signed off by
Janni Hares
Database
Frankfurt
Open live preview ↗
Example of a feature sign-off. You get this overview for every feature.

Result: a ready-to-use MVP that can keep growing afterwards.

Afterwards, if you like

Operation

If you like, we take over hosting in Europe, technical monitoring, updates and maintenance for a fixed monthly price. We agree the scope to fit your product. New features and larger extensions are agreed with you separately.

Hosting in Europe

Hosted in Europe, database in Frankfurt. If you later want to move to your own servers, that works without a rebuild.

Monitoring and updates

We monitor availability and errors, apply security updates and keep dependencies current.

Maintenance at a fixed price

Small changes and fixes are included in the fixed monthly price. The scope is in the quote upfront. Larger extensions run as Prototype Loops.

Result: a supported product with clear responsibilities and predictable running costs. Code and project knowledge belong to you.

Our principles

  • See before you build

    Prototype and flows are settled before development starts.

  • Decisions in one place

    You decide deliberately, not in passing.

  • Tests first

    Every feature is checked before it goes live.

  • A person signs off

    AI helps build, we are accountable.

  • Fixed prices

    Binding fixed prices, based on real measurements.

  • Data in the EU

    Hosting in Europe, database in Frankfurt.

  • GDPR and accessibility are part of the tests

    Both are checked before every feature, not at the end.

  • You own everything

    Code, documentation, decisions.

Questions about the process

Do we always have to start with the first stage?
What do we get at the end of each stage?
How is the fixed-price quote put together?
How many Prototype Loops does it take to reach the MVP?
What role does AI play in development?
Who runs the software after launch?

Already have a clear scope or a design? Then we start right at the prototype.

Request a first call

30 minutes, an honest assessment, start within days.