Software development has become cheaper and faster than ever. What remains scarce is judgement. We believe software carries the business, not the other way around. It should fit, run early and be built with sense. These three convictions shape every project we take on.
ERP systems and off-the-shelf software force your company into someone else's processes. We turn that around: your workflows define the software, not the other way around. The result is software your people actually enjoy using, because it does exactly what the operation requires — nothing superfluous, nothing cumbersome. This stance isn't new — it was simply too expensive for a long time. Standard software prevailed because custom-built solutions cost a multiple and took months or years. AI-assisted development has shifted that ratio. Today we can build the digital backbone of a company in a fraction of the time and at a fraction of the cost. What used to be a corporate privilege has become an SME tool. What does «software that fits» mean concretely? You avoid the typical shadow processes — Excel sheets alongside the ERP, double data entry, small workarounds employees adopt in secret to stay productive. You avoid the hidden adjustment costs of standard software: customisation consultants, update risks, multi-year rollout projects. And you gain a system that can grow with your company, instead of forcing you into the next migration in five years. We speak deliberately of a digital backbone. For many companies, software today is no longer an aid but the actual operating system — fundamentally anchored in workflows, not merely processes on paper. If that operating system is foreign, your company lives in a foreign house. We say this openly: there are cases where standard software is the right answer. Accounting, payroll, mainstream CRM for classical sales processes — available solutions often suffice here. We recommend that when we see it that way, and we decline projects in which a standard tool would serve the client better.
For a Swiss insurance broker platform we built a solution that covers the full lifecycle — from inquiry through quote to claims handling. Standardised insurance software focuses on insurers, not brokers. Generic CRM systems don't understand the complexity of policy lifecycles. A custom-built solution wasn't a luxury here — it was a precondition.
Speed doesn't come from frantic programming, but from clean decisions. We know business processes because we've spent two decades across industries from banking to insurance, from healthtech to higher education. That means: we listen to your requirements, translate them into pragmatic technical decisions, and move into implementation early. After a few weeks you log into a working system and steer it actively. This isn't speed for its own sake — it's accelerated clarity about whether you're on the right path. Most software projects fail not from a lack of speed but from a lack of decisions. What looked at the start like a clear concept turns out three months later to be a collection of assumptions nobody really stands behind. Classical waterfall projects try to close this gap with ever more elaborate concepts. We go the opposite way: we build a living system early, in which assumptions become visible before they become expensive. This method isn't new. It's called Extreme Programming in the technical literature and it's older than Scrum — formulated by developers who watched waterfall projects fail in the late 1990s. We work in that tradition: small working increments, regular customer access, fast iteration. What has changed since is the technology. AI tools have dramatically shortened the speed at which increments come into being. Business understanding concretely means: we listen to your requirements, but we don't take them one-to-one as a build plan. Requirements are rarely exactly what is truly needed. An experienced partner hears the requirement, recognises the underlying business problem, and sometimes proposes a different solution — leaner, more robust, or simply more suitable for your industry. This translation work is the difference between a code supplier and a technical co-founder. An idea is free. Value emerges in execution — and certainty only emerges when that execution is tested in the market. Anyone who delays the first reality check by six months because «the concept isn't ripe yet» wastes six months of learning. We rarely see this as a question of courage. It's a question of method.
At VERSIFY the pilot operation went live after four months — possible because the market was clear and the customer could decide quickly. At rosypet, a platform for the veterinary medicine market, the MVP phase took more than two years — deliberately, because the market reacts slowly to digitisation and the concept had to be aligned with stakeholders across several iterations. Speed doesn't mean «always within four months», but «as fast as makes sense in any given project».
AI makes development faster, more precise and cheaper — but only if someone sets the direction and reviews the results. We've used AI since ChatGPT became publicly available in November 2022, and over those years we've learned where it shines and where it leads astray. That's why we pass part of the efficiency gains directly on to you — and at the same time you lose no quality, ever. The software world today splits into three camps. The first ignores AI because its own craft is enough — and falls increasingly behind the market. The second follows AI blindly, lets it generate code, and accepts whatever looks plausible — producing systems that feel magical for three weeks and become unmaintainable in three months. We belong to a third, smaller camp: AI is a tool, not an author. It amplifies our work; it doesn't replace the judgement over it. We know where AI shines: in fast first drafts of code, in exploring solution spaces, in documentation and tests, in translating between requirement and implementation. We also know where it leads astray: in architectural decisions with long-term consequences, in subtle security questions, in business logic that needs more context than the current conversation provides. This distinction is not trivial. It comes from experience — from building, from observing the results, from fixing our own mistakes. Whoever has the technical background and gives the right instructions gets something with AI today that feels like superpowers. Whoever has neither lives through the first magical third of a project — and then stumbles into a loop of debugging, structural problems, and code nobody can read any more. We see this regularly in projects that began as pure AI improvisation and ended in a dead end. The repair then costs more than a clean start. In concrete terms, AI-native means this for us: we use the best available models and tools — today that's primarily Claude Code for development work, alongside specialised tools for research, code review and test generation. We continuously develop our own methods, because the field is changing faster than any curriculum. And we pass part of the efficiency gains on — in shorter project durations or lower hourly rates, depending on the agreement. You don't lose quality in the process. You gain a team that already masters the tools of the next decade.
At VERSIFY we implemented agents that analyse and compare insurance contracts and pre-review claims. Three requirements had to be met at once: the LLM models must remain interchangeable at any time (OpenAI, Anthropic, Google). The workflows must produce repeatably precise results — not merely plausible, but well-founded. And the data must be processed under Swiss data protection law, which restricts the model choice. This is exactly where the difference shows between «quickly add an AI feature» and «operate AI functionality at a business level».
Every project is different. What doesn't change is the structure we run it with. You get predictability without rigid waterfall logic — five phases, clear transitions, joint decisions at every gate.
We clarify together what should be built — and what shouldn't. We listen, ask the uncomfortable questions, look at your existing systems. The result is a concrete requirements outline, an initial architecture recommendation, and an honest effort and timeline estimate for the main phase. You then decide, well-informed, whether we move forward together.
One to three weeks
We build a first clickable prototype — not a mockup, but a running system with the most important functions. You test, give feedback, correct course. With AI assistance, first versions take shape faster than was possible just a few years ago.
Two to four weeks
From the prototype the full system grows step by step. We work in short cycles, with regular exchange, with progress visible to you. You can shift priorities, add or drop features at any time — the architecture supports that, because we designed it that way from the start.
Two to six months
The system goes into operation. We accompany the launch closely, watch the first real users, fix what only the real operation reveals. You take over the software, the data, all access credentials — from day one.
Transition in days
Most systems live for years. We stay on board for as long as you wish: for ongoing adjustments, new features, reactions to market changes. Or we hand over cleanly to your own team or another partner.
As long as you want
At every phase transition you can step out or change direction, without falling into a contract trap. It's the only responsible way to run a long-term project.
Software only becomes a digital backbone when it stands on solid ground. Three points matter to us here — and they're not marketing claims but working principles.
Our founder Stefan Hess spent ten years in Swiss banking IT, including high-security data centres, core banking systems and security operations. That experience shapes how we build: test systems instead of direct production access, documented change processes, rollback options, penetration-test awareness. We also know what's not needed: no company requires bank-grade standards, but every company deserves security that fits its industry.
We've spent years building for industries where data protection isn't optional but mandatory: insurance, education, healthtech. We work with Swiss hosting providers when the data requires it, and we choose AI models operated in Switzerland or the EU when that's necessary. The trade-off between «latest AI model» and «privacy-compliant» we make deliberately, with you, not behind the scenes.
You own the source code, the data and every access credential — from day one. We build with established open-source technology. If you ever part ways with us, any competent developer can take over. This transferability is part of our architecture, not an afterthought.
You own the source code, the data and every access credential — from day one. Three points make that concrete.
You own the source code, the data and every access credential — from the first commit on. No licence, no rental arrangement, no vendor account held in our name.
We build with Laravel, Vue, Node and standard databases. No proprietary frameworks that only we understand — only tools with a real market of developers behind them.
Should you ever part ways with us, any competent developer can take over the work. This transferability is part of our architecture, not an afterthought.
The best way to find out is a conversation. First calls are non-binding, free of charge and confidential. We don't sell, we listen — and we'll tell you honestly whether we're the right partner.
