Manifesto
These are our beliefs about building enterprise software — written down so they can be argued with, agreed with, or quoted back to us when we forget. We revise them when we're wrong, and we date the revision.
The roadmap is a guess. The release is a fact. We optimise for facts.
Article V — On scope
Ten articles · in order
Software is built by people, for people. Care shows in the code — in the choices that never appear in a demo, in the seams nobody asks about, in the parts only the next engineer ever reads.
At enterprise scale that difference compounds for years. We build as if we'll be maintaining it — because we usually are.
When we commit to a date, we mean it. Estimates are promises with confidence intervals, and we honour both. If something slips, you hear it from us first — in writing, with a reason and a new date we also mean.
Velocity isn't the goal. Shipping the right thing on a date you can plan a business around is.
We choose proven technology where it pays off in maintenance and modern technology where it earns its keep in velocity. Novelty for its own sake is a tax on whoever inherits the system.
The boring answer has often been the right one for a decade. We won't abandon it because someone wrote a launch post.
We don't ship code we wouldn't be on call for. End-to-end engineering means we sign the deploy, not just the design — and we read the alerts the next morning whether anyone is watching or not.
If it breaks, we fix it. If we caused it, we say so. The fastest path to trust is being first to raise the bad news.
Smaller, sharper, sooner. We'd rather ship three things that work than promise twelve that mostly do. Cutting scope isn't a failure — it's the discipline that keeps the surviving features good.
The roadmap is a guess. The release is a fact. We optimise for facts.
One accountable team, one voice. You won't be handed to a rotating cast or an account manager reading from a script — the people who design your system are the people who build and run it.
We work with clients we're proud to work with, on terms both sides would describe the same way.
We'll tell you when we think you're wrong — privately, with reasoning — and we'll be wrong sometimes too. Honest is faster than diplomatic, and respect is the floor, not the ceiling.
A partner that only ever agrees with you isn't a partner. It's a billing department.
Code outlives the project that created it. We write for the engineer who inherits it three years from now — who may not work for us, and may not work for you either.
That engineer deserves comments where they help, types where they catch, tests where they pay rent, and a build that just runs. Anything less is a debt taken out in their name.
A tool, not a religion. We use models where they earn their place — in products, in interfaces, in the dull work where pattern-matching beats typing. We don't ship production code we can't defend at review.
We won't sell you the dream of the day after tomorrow. When we're unsure something will work, we say so plainly and ship the smallest thing that settles the question.
We do excellent work for fair terms, and we scale deliberately — senior-heavy teams, never growth for its own sake at the cost of the work.
Lumy exists to make software worth using — for clients we're proud of, on terms that leave the next generation of engineers something better than we found. That's the whole standard.
Position taken — 03 June 2026
Disagree?
We read every honest reply — and we revise this page when we should.