Build it yourself or build it together: we think along
Aziri also builds with companies that want to develop their own applications or take part in building them. Your own people build in the same project, or continue on a foundation we set up. We look after the data model, the security and the code that goes into the application.
Aziri is a Belgian software company from Zonhoven that has built custom software for businesses since 2018. Below is how such a collaboration works, and when building it yourself is a good idea.

Some of our clients
Why do more companies want to build their own app?
With AI tools, someone without programming experience can build a working prototype in a few evenings. So we are asked more and more often whether a company can build itself, or help build the application we make. Our answer is yes, because we have always built software together with the people who use it.
Building it yourself is a good idea as long as someone with technical knowledge keeps a critical eye on it. AI is quick to approve its own work, and a mistake in the data model or in user rights only shows once real data is in. That is where we come in: we set up a sound foundation and review, so your people can keep building safely.
What forms of co-development are there?
Four ways we work with companies that want to build themselves. Within one project you can move from one to another.
| Form | What you do | What Aziri does | When it fits |
|---|---|---|---|
| Building together in one team | Your own developers or IT build parts, each on their own branch of the code. | Sets up the project, builds the heavy parts and reviews every change before it goes into the application. | You have your own IT or developers and do not want to depend on an outside supplier. |
| We lay the foundation, you continue | After a short training you make smaller changes yourself: layout, buttons, reports, an extra field. | Builds the first version with the data model and complex parts, and stays available for bigger work. | Someone on your team is good with computers and does not want to wait for every small change. |
| You build, we review | You build yourself, for example with AI, and run your choices past us. | Thinks along about the structure, reviews the code, tests and says what has to change before go-live. | You already have a prototype and want to know whether it is solid enough to run on. |
| We take over what you built | Show what exists and how it is used. | Does a short review of the application and proposes how to maintain or extend it. | Your home-built tool has become important and its builder no longer has time for it. |
For every form we agree up front who builds what, who reviews what and who maintains the application afterwards.
What do we think along about when you build yourself?
These are the parts that save you the most work later if they are right from the start.
Structure and data model
Which tables exist, how they connect and how numbers and statuses work. Changing a data model afterwards costs far more than reworking a screen, so we usually take this on ourselves.
Security and user rights
Who can see and change what, per role. Especially when customers or suppliers log in, we check that nobody sees data not meant for them.
Integrations
How your application talks to your accounting, ERP or payroll provider, and what happens when that integration is briefly down. We have built more than 70 integrations with 70 systems.
Code review
An Aziri developer reviews every change before it goes into the application. That way your IT lead knows that code written with AI is checked too.
Testing and going live
A test environment next to the live one, so you try changes with test data first. Only then do they go live, with backups of the data.
Who maintains what
Who fixes a bug, who runs the updates and who decides on new features. We write it down before anything is built, so there is no discussion later.
When is building your own app a good idea, and when not?
Building it yourself pays off mainly when the people who know the process also like working on the software. Clients who built one or two applications with us sometimes went on to build several more themselves. It works well in these cases:
- It is about small changes, reports or an internal tool for a limited number of users.
- Someone on your team has basic technical knowledge, or wants to build it.
- That person actually gets time for it, next to the day job.
- You want to be able to adjust quickly when the way you work changes.
Leave the building to us if nobody on your side can review it technically, if it holds sensitive customer or financial data, or if the application has to talk to many other systems. If your people are already stretched, start with us and build the in-house knowledge in a later phase.
How do you limit the risks of building yourself?
What we agree when your people work on the code too.
The application depends on one person
Agreements, choices and tickets are on a project board, and the structure is described. If your builder leaves, someone else can take over.
Unclear ownership
The code we write together and all your data belong to you. If part of it runs on a third-party platform, your proposal states how a handover works.
No documentation
With every change, the description of the structure, the data model and the integrations is updated too, also when AI wrote the code.
A change breaks something
Test in a separate environment first, then go live. An Aziri developer approves the change.
Rights too broad
Rights per role, checked by us. Whoever builds gets access to what they need and no more.
Lost data
Backups of your data, secure access and updates. If we host the application, that is included in the annual licence.
Which clients have we already built with?
Two client cases in which the client built along or went on building themselves.
Eddie Stobart: built with their own IT
An outdated damage claims system became an application of their own, built together with Eddie Stobart’s IT department. That way they could build along, and a first version was running after one month.
Read the case →Warsco: building on after training
After four days of training, Warsco develops the application we set up together further itself. As the team gets to know the building blocks better, it also wants to automate other processes this way.
Read the case →
What does building together cost?
If we build the first version, the price is the same as for custom software: from €5,000 for a first defined application, such as one process, preferably at a fixed price up front. An integration between two systems starts from €2,000. Licence and hosting come on top, from €1,000 per year.
For reviewing, code checks and training, the price depends on how much you build yourself and how much we review. We agree it per project, and you know it before we start. How we arrive at a price.
Frequently asked questions
Question not listed? Ask us directly.
Can we keep building on the app ourselves?
Yes. We build so your own people can make smaller changes themselves after a short training, such as layout, reports or an extra button. Bigger changes to the data model or user rights we look at together, and an Aziri developer reviews them before they go live.
Can you teach us to build with AI?
Yes, within a project around your own application. While building we explain which choices we make and why, and afterwards we review while you build. We do not give stand-alone AI courses without an application.
Will you take over what we built ourselves?
That is possible, after a short review of the code, the data model and the security. We then propose how to maintain or extend it. If the foundation is too shaky to build on, we say so honestly and tell you what a rebuild would cost.
Can we get the code in our own Git environment?
If you want to, yes. The code then lives in your own repository (for example GitHub, GitLab or Azure DevOps) and we work in it together.
Do we need developers on staff to build along?
Not for smaller changes: someone who is good with computers and gets time for it is enough. If your team builds bigger parts itself, someone has to review them critically from a technical point of view. We can take on that role.
Who owns the code if we build together?
The code we write together and all your data belong to you. If part of it runs on a third-party platform, your proposal states up front how a handover works.
Who is responsible if something goes wrong?
We agree that up front. For what we built and reviewed, we stand behind it through support with fixed response times. That way everyone knows in advance who to turn to.
Want to build yourself, or build along?
Tell us what you already have and who on your side wants to build. We will suggest a split that fits your team.
We reply quickly.
