A Mendix developer you rent
by the build-day.
Marcus reads your requirements, builds against your model, drives the running application to prove the work, and hands back the evidence. It runs on isolated infrastructure, and someone at Kinetech reviews every build-day of output — including the ones you never look at.
MARCUS — Managed Agent Resource Constructing Unbelievable Software. The bold word is only safe because of the evidence behind it.
The whole picture
One model. Every phase of your delivery loop.
Marcus is not a coding assistant bolted onto one step. It reads and writes the model itself, which is why it can act in every phase — and why the evidence it produces is the same evidence in all of them.
What follows
The whole argument, in order
A governed Mendix developer you rent by the build-day.
It builds against your model and proves the work by running it. You keep the approvals.
Six gates, every build graded, and a green compiler that hid six real defects.
Vendor support dates already on the calendar, and some of them have passed.
Three factors move the number, and we show you which ones moved yours.
Tell him where you are and leave with a range you can act on.
Three ways in
Start where you actually are
Rent delivery capacity
Your own governed Marcus instance with capacity you size, and a human at Kinetech reviewing every build-day of it. For teams with more roadmap than developers.
Get off a legacy system
Marcus reads your source — screens, schema, and the rules buried in code nobody has opened in years — and turns it into a specification you can argue with before the rebuild starts.
Have an application reviewed
A read-only pass over a Mendix application you already have: security and access, upgrade path, model quality, performance. Three to five days, and you keep the report.
What changes
What you actually get out of it
Capacity in days, not hiring cycles
Add delivery when the roadmap needs it and stop when it does not — without a recruitment round, a ramp-up, or carrying the cost through a quiet quarter.
Work that arrives proved
Every screen opened and driven as a real user before anyone says it is ready, with the evidence attached. You are reviewing a demonstration, not a status report.
Nothing ships without your say-so
The approval gates stay on your side throughout. Marcus proposes and proves; a human on your team decides.
A system your team can keep
Your model, your repository, documented as it is built — so what you are left with survives without us, which is the point rather than a courtesy.
On a real delivery the model compiler reported zero errors on a build carrying six real defects. Driving the running application and screenshotting it is what found them.
A client watching a green dashboard would have shipped all six. That is why a human at Kinetech reviews every build-day of output — including the ones you never look at — and why that review is priced in rather than sold as an upgrade. See the console →
How it works
Work is pulled from a queue, not assigned to a person
A unit of work is one story at one stage. A worker takes the next unit it is qualified for, does it, records its evidence, and asks for another. Finishing a stage is the handoff — nothing is routed by hand, so capacity is added by adding workers.
1 · Intake
Your specification, legacy database and screens become epics and stories with acceptance criteria you can argue with.
2 · Build
Each change is authored as a re-runnable script, applied to your model, and compiler-checked. Nothing is hand-edited into a binary nobody can review.
3 · Verify
A separate worker drives your running application and screenshots it. A green build is not accepted as proof of anything.
4 · Review & integrate
Kinetech reviews the output, then the change is replayed onto your branch with its modeler metadata intact.
What we will not pretend. Throughput is bounded. Shared surfaces — navigation, security, the common model — are single-writer, so beyond roughly six to eight concurrent workers you are queueing, not scaling. We size to that reality instead of selling workers that would sit idle.
What it costs
You are not renting a box
You are not renting a box. What it costs depends on what the work actually is, how much capacity sits behind it, and how fast you need it — so every figure here is a range, and we show you which factor moved yours.
1 What the work is
Keeping something running, building new capability, getting off a legacy system, or work that has to prove itself to a regulator. Verification effort per story is not constant across those.
2 How much sits behind it
How many lanes run in parallel. More is faster until it isn't — and we will tell you where that point is for your model rather than sell past it.
3 How fast you need it
Review effort scales with the amount of work, not the calendar. Compressing the same scope into half the time concentrates the human cost rather than spreading it.
Go deeper
The whole argument, in writing
The offer, in full
The complete client write-up: approval gates, division of labour, the comparison matrix, and how onboarding runs.
How a Marcus instance works
The full proposal: architecture, where every call goes, and an honest account of what we do and do not run ourselves.
Tell Marcus where you are — you will leave with a range, the assumptions behind it, and the answers that would narrow it.
Talk to Marcus