Manifesto
We are a small developer-led team that takes responsibility for code, technical decisions and the system after launch.
Where we stand
In a typical agency your decision travels through corporate layers of people who do not understand the technology, and only then reaches a developer – then comes back the same way. Every hop is a delay and a place where context gets lost. Here, the developer writing the code and the client talk directly.
The most expensive hours are often the ones that do not move the project: status calls without decisions, context handovers and estimates detached from code. We prefer a short backlog, a clear priority and work visible in the repository.
Hard builds ship when the people doing them know the code, can spot risk and can say clearly what should be done now and what should wait.
The usual problem
“Anti-Software House” does not mean we dislike software houses. It means we cut out the specific mechanisms that cost the client the most and give them the least.
In a classic agency there is at least one layer of middlemen between you and the developer. A product manager translates your words into project language, someone else passes them on, and in the end the person who knows the most is the one writing the code – the one you speak to least often. The result is a game of telephone: longer iterations, lost context and technical decisions made far away from the code.
The second thing is the cost of context switching. The more people sit between decision and implementation, the harder it is to keep technical direction, accountability and pace aligned.
Our answer
Calling it a rebellion would be too much. We simply cut out everything that does not build your system – and kept the people, the code and the rules of the game in the open.
We are a three-person team with 39 years of commercial experience between us. That means the person you agree the scope with is the same person who then codes it. There is no moment where knowledge of the project gets diluted in a handover between departments.
We work end to end on one coherent stack: Magento 2 with Hyvä and Hyvä Checkout for e-commerce, and Symfony, Laravel, Pimcore and Open Mercato for bespoke systems – plus Node.js and React wherever the interface has to be highly reactive. Integrations, storefront and backend are run by the same people, with no seams between “external” teams.
We operate in two modes: we build from scratch and we take over projects started by other vendors. That second case shows the point of our model best – we clean up someone else's code, bring the project back to stability and keep it moving, sometimes through many years of continuous development.
Our toolkit
New tools do not change our rule: quality and decisions belong to an experienced engineer. AI should raise the bar, not lower it.
We do not replace experience with automation and we do not paste in code we do not understand. Every change goes through senior review, and architectural decisions are made by a human – because those are the ones that stay in the system for years.
We treat AI like any other part of an engineer's toolkit – the compiler, the debugger, the tests. It should speed up the work and raise quality, not replace thinking. We use it where it genuinely helps: understanding large and legacy codebases, boilerplate, tests and a first pass over changes.
The effect is simple: less time on routine, more on hard problems. What AI takes off an engineer's plate goes back into the project as attention paid to architecture, performance and security.
Let's talk
If you are looking for a vendor whose first priority is getting your project delivered properly, you are in the right place. Tell us about it – a Magento build, a Hyvä migration, a bespoke system or something to take over from a previous vendor.
How we work
Time & material billing, direct contact with an engineer, an engagement horizon measured in years.