Web and mobile applications, APIs and business systems built on how you actually work. Every feature answers a constraint that exists in your process.
We read the process with you: who uses it, where it jams, what has to stay on. Then we build what is needed, with tested code that whoever inherits it can read. Code, access and documentation are yours from day one.
What it covers
- 01Web and mobile applications
- 02APIs and system integrations
- 03Custom business systems and internal portals
- 04Evolution of software already in production
When custom software makes sense
A process everyone runs the same way should be bought: accounting, email, a basic CRM. Custom software makes sense when the process is what sets you apart, or where a mistake is expensive: how you take a booking, how you compute a price, how you follow a case across ten different actors.
The first thing we do is tell you which of the two is your case. It happens that we recommend an off-the-shelf product and a small integration instead of a project. It is the phase we call decision, and it is worth more than any line of code written afterwards.
Starting from scratch or evolving an existing system
From scratch: the problem exists, the product does not yet. We do analysis, architecture, interface, development, infrastructure and release, with the same people from start to finish. That is how the platform that replaced a twenty-year-old system for an insurance group was born, used today by more than 400 agencies.
From what's there: software, data, integrations, the people who know them and constraints nobody can reset already exist. We step into your team's code, with its conventions and its pipeline, and change what is needed by degrees. It is the case of the forty-microservice ecosystem where in eight weeks we became the first contributor on five repositories.
Most real projects sit in the middle: a new piece that has to live alongside a running system. That is why the initial reading always includes what is already there, even when the request is a new product.
How we approach a system already in production
The map first: which domains exist, who depends on whom, which data lives where, which integrations cannot be touched. We write it before opening an editor, because the map decides the order of work.
Then progressive migration. We prefer to let the new take on one responsibility at a time, with a compatibility layer in front, so the rest of the system keeps seeing the contract it knows. Every step has a clear boundary and a way back. It is the pattern we used to move dozens of services from REST to GraphQL without touching the frontend.
Parity is verified on real data. When a refactor has to return the same results as the code it replaces, we compare outputs on real cases before release: that is how you find one extra promotion or a price one cent off while it is still a bug, before it becomes a complaint.
Fragile integrations get a switch. An ERP in transition, a vendor changing its API, an expiring certificate: the flow must be able to continue in a degraded, legible way, alerting whoever handles the case by hand, instead of stopping.
What we actually deliver
Repositories in your account, with a readable history. Infrastructure described as code. Test and release pipelines that run without us. Reproducible development, staging and production environments. Architecture and decision documentation inside the repository, where whoever arrives can find it. Access yours from day one.
If one day you change supplier, whoever arrives finds a system that explains itself. We consider that part of the job.
How we work with an internal team
We sit in your flow: your code conventions, your ticketing tool, your weekly releases. Reviews go both ways, and the decisions that matter stay written with their reasons, so that a year from now people know why something is built the way it is.
Responsibilities are explicit: who has the last word on architecture, who releases, who answers for an incident. When your tech lead keeps architecture and review and we write most of the code, it works. When we need to set the architecture and your team adds endpoints on top, it works too. What matters is that it is written down.
Where we apply it
Questions
Before writing to us
When does custom software beat an off-the-shelf SaaS product?+
When the process is what sets you apart, or when a standard product forces workarounds and spreadsheets. If a ready-made product covers almost all of the need, we say so: that is part of the filter.
How much does custom software cost?+
The cost depends on a few factors worth settling before asking for a price: how many processes it must cover, how many existing systems it has to talk to (business system, ERP, payments), how much data has to be moved from the old system, how many roles and permissions are needed, which security or regulatory requirements apply. Data migration and maintenance after go-live are the items most often missing from quotes. When two quotes are far apart, they usually describe different scopes: ask each supplier what they left out, and start with a small first piece that people actually use.
How do you change business system without losing data?+
You clean the data in the old system before moving it, rehearse the migration several times on a copy comparing counts between old and new, and switch one area at a time with both systems running side by side for a while. Switchover day should repeat rehearsals that already succeeded. Before signing with a new supplier, also ask how you would export your full history, and in which format, if one day you wanted to leave.
Do we own the code?+
Yes. Code, access and documentation are yours from day one, in repositories you control. Whoever inherits the system must be able to read and change it without us.
Describe the system. We'll tell you what we see.
Ten minutes, one question at a time. At the end, our honest read of the case. It's the filter, before the call.