Client case: an MVP shipped in 18 hours of work, hosted for under €8/month

Two questions come up every time someone hands me a project: how long before something usable exists and how much will it cost to run once it's live. This case answers both, with real numbers rather than estimates.

The need

A real agricultural cooperative in Benin needed an application to track its supplies, monthly costs, production and margins. Users who count their bags of fertilizer to the kilo — not a demo, not fictional data.

What was delivered, and in how long

The product was designed, built, tested and shipped in 18 hours of effective work, spread over a few days. Within that window:

• A complete application that works offline (the field in Benin doesn't always have mobile data), with multi-currency Excel export
• Custom-built secure authentication (not an unverified third-party module)
• An automated test suite that actually films the user journey on every update and publishes the video — documentation isn't a file written once and forgotten, it's proof that renews itself with every change
• An automatic deployment system: every validated update goes to production with no forgettable manual step

That timeline was only possible because the framing was done upfront — a clear, versioned brief, and systematic verification at every step rather than blind trust in the tool.

Rigor didn't slip despite the speed

This is the point that matters most to a client: shipping fast doesn't mean shipping less verified.

• Security verified, not assumed. A login rate limit was added after reviewing production logs — vigilance didn't stop at the first deployment.
• Zero undocumented shortcuts. No leftover "TODO" or temporary fix in the delivered code.
• An error caught before the client. A typo in a sample file was spotted and fixed before go-live — because someone took the time to actually re-read it, which few providers really do.
• Proof rather than a promise. The video above isn't a touched-up screen recording: it's the automatic report generated on every test run. If there's any doubt about a behavior, the video settles it.

The real hosting cost, measured line by line

This is where this case stands out: rather than claiming "it's a lightweight stack" without proving it, every cost item was measured directly on the production server.

The technical choice (a compiled, resource-frugal language rather than a heavier stack to run) explains much of that gap: at equivalent traffic, this type of architecture commonly uses 5 to 40 times less compute than more common but heavier stacks. On a low-cost server, that translates directly into a hosting bill that stays low even as usage grows.

Why it matters to you

• A predictable, low hosting budget, not an optimistic estimate that blows up at the first traffic spike.
• Security verified at every step, not a checklist ticked once at kickoff and forgotten.
• Proof rather than a promise taken on faith: every delivery can come with a verifiable report, like the video above.
• Sustainable software that isn't a marketing line: the figures above are measured, with the method and the limits of that measurement documented transparently — I don't hide what I couldn't verify directly (no physical power meter on the server, for instance, so CO₂ figures aren't included here: only what I could measure directly is).

It's this same method — clear framing, systematic verification, measurement over estimation — that I apply on every engagement, whatever its size.