DEV Community

CJDARKLORD
CJDARKLORD

Posted on Originally published at tenlux.tech

MVP in two weeks: what a team can actually deliver

"Build an MVP in two weeks" is a reasonable request — and it fails for one predictable reason: people read "MVP" as "the real product, but smaller". It is not. Two weeks is ten working days, and ten working days buys you one scenario end to end, not a scaled-down app.

Here is the day-by-day plan we actually run, and two of our own projects with real commit dates.

Two weeks = one scenario

A two-week MVP fits:

  • one core scenario: the user did X and got Y;
  • working on the customer's real data;
  • basic navigation and readable screens;
  • error handling and a crash log;
  • a build that installs on a device;
  • a one-page manual and an explicit list of limitations.

It does not fit:

  • a second scenario, roles or permissions;
  • imports from third-party systems and history migration;
  • a design from scratch based on a brand book;
  • auto-update and code signing;
  • a store review (RuStore, Google Play);
  • an admin panel, payments, subscriptions, analytics.

If the request includes two items from the second list, the honest deadline is "two weeks for the pilot and another month to launch". That is not resistance — it is arithmetic.

Day by day: 10 working days

  1. Days 1-2. Brief and boundaries: what counts as "working", who the user is, what data goes in. A 3-5 screen prototype and sign-off on the scenario.
  2. Days 3-5. The core, no polish: data, calculations, saved results. External sources get wired in on a real example, not on mocks.
  3. Days 6-7. The interface around the core, error states, empty screens, progress for long operations.
  4. Day 8. A run on the customer's real data, on 3-5 devices. This is where deadlines break: file formats, sizes, access rights.
  5. Day 9. Polish, build, crash logging, install from scratch on a clean device.
  6. Day 10. Acceptance against the scenario, manual, limitations list, plan for the next stage.

There is no "day to approve mockups" and no "day to redo". That is why the brief at the start is half the job.

Case 1: TenDrivers — scaffold in a day, usable beta in four

TenDrivers is a Windows tool that finds driver updates and installs them with a backup and a restore point. The commit dates say more than any estimate:

  • 12 Nov — first commit: device inventory via WMI (Win32_PnPSignedDriver), Windows Update as a source through the official COM API, driver backup (pnputil /export-driver), restore point (Checkpoint-Computer), a dark WPF interface and a CLI harness to test sources without admin rights.
  • The same day — driver rollback from INF, device filters, CSV export. The MVP scaffold came together in one day.
  • 13-15 Nov — 0.2.1 → 0.3.0 (official Dell Command Update and HP Image Assistant channels) → 0.3.1 (parsing their XML reports) → 0.3.2 → 0.3.3 (direct update links, portable build).

From scaffold to a beta you can put on someone else's machine — four days. Why so fast: one scenario ("show me what is outdated and update it safely"), official sources only, and the risk removed by backup and restore point — written first, not "later".

Deliberately left out: BIOS and firmware, silent "update everything", point updates for Dell/HP (their CLIs cannot do it), testing across every vendor's hardware fleet, code signing.

Case 2: Stream Subs — scaffold on 10 Oct, public 1.8.1 on 19 Nov

Stream Subs does offline live subtitles: PC audio → VAD → Whisper → WebSocket → OBS, with 0.3-0.7 s latency per phrase. From the first commit to the public 1.8.1 release about five weeks passed — not because the deadline slipped, but because it was a different class of product.

  • The core scenario worked early: audio captured, recognised, the line goes to OBS.
  • Version 1.3.0 added a native window and tray, a WebView2 check, a silent launcher, correct installer paths. None of that was in the MVP; without it the product cannot be handed to people.
  • 1.7.7-1.7.9 came as three releases in a row on the same class of bugs: running from the install directory, embedded Python on sys.path, behaviour on window close, overlay recovery after reconnecting.
  • 1.8.0 replaced NLLB (CC BY-NC, non-commercial) with M2M100 and Helsinki opus-mt — a licence problem discovered late, and the most expensive lesson in the project.
  • 1.8.1 shipped two builds (NVIDIA and CPU), no Python required on the user's machine, sha256 sums, published on the site and on GitHub Releases.

The lessons: check model licences before they become part of the architecture, and remember that the installer solves half of your users' problems. "Install Python and the libraries" kills conversion faster than any bug.

How to accept an MVP

  1. The core scenario runs on real data, not demo files.
  2. Verified on 3-5 devices (OS versions, screen sizes).
  3. Errors are not silent: there is a log or a clear message.
  4. A clean install on a fresh device works without your help.
  5. There is a one-page manual and a list of limitations.
  6. It is clear what the next stage costs and how long it takes.

Acceptance by this list takes an hour and removes 90% of "that is not what we agreed" disputes.

What comes after

A 2-4 week pilot with real users, iterations on what actually breaks, then a store release (signing, listing, screenshots, review) as a separate task, and updates with a changelog. An MVP is not a "smaller version of the finished product" — it is an instrument for testing the core scenario on real people at minimum cost.

The full version of this article, with the detailed table of what fits, is on our site: MVP in two weeks: what a team can actually deliver. We are a small studio that builds apps, bots and desktop tools — TenLux.

Top comments (0)