← Back to news

Vibecoding and Self-Hostable apps. Is there a place for these apps to land?

November 11, 2026
Vibecoding and Self-Hostable apps. Is there a place for these apps to land?

This is nowadays every IT department's reality. Not being ready, not having answers to these inquiries and saying your users "come back in a quarter", will mandatorily cause then to find alternative solutions and is the paved way to shadow IT situations.

How do we make sure these applications do not ease the exfiltration or manipulation of corporate data in untrusted places? How do we guarantee the sustainability of applications that, once deployed, are often adopted massively and quickly become critical? An end user's laptop is not an option. Neither are the free hosting services that AI tools happily connect to.

Governance is needed here, and it is key that IT is ready ahead of time, able to answer users' needs fast. Otherwise they will find their own way, and that way is shadow IT.

The expectations have moved tenfold

Intense, easy code production raises what users expect, and not only from their own prototypes. The number of good open-source applications, built in record time and well maintained, is teasing them too. It pushes them to install whatever it takes to assess these applications, and sometimes to make them productive, hosted on their own computer or on third-party platforms that are not suitable for production.

By doing so they escape IT's vigilance entirely. Often without knowing what they are doing, they generate shadow IT, create security exposures, and sometimes put corporate data and business continuity at stake.

It cannot be parked for later anymore

Business users, analysts and teams without a developer now arrive with something that already works, built with AI assistants. They have a real need and a prototype that answers it. This is no longer a trend to watch. It is what walks through the door every week.

The usual feedback of overwhelmed IT teams to these requests, "come back next quarter, we need time to study what can be achieved", does not stop users anymore. It sends them elsewhere: a personal subscription, a shared password, an application nobody in IT knows about, that is not properly protected, that cannot be audited and that may let critical corporate data escape any control. Parking requests because "we are not ready" is exactly what pushes people to find their own solutions. Hiding the topic under the carpet does not make it go away. It makes it invisible, and it leads straight to shadow IT.

Three kinds of applications at your door

Vibe-coded applications get the headlines, but they are only one of the arrivals. A useful front door treats each by what can actually go wrong with it, and by what it takes to host and build it while meeting all the associated goals: security, cost, compliance, flexibility and ease of deployment. We identified three kinds:

  • Self-hosted open-source applications. Developed by a public project the organisation does not control, but decides to host. This is Lane A.
  • In-house and vibe-coded applications. Built by developers, or by business users with AI assistants. They face the same constraints and the same risks, so the front-door checks for one are valid for the other. This is Lane B.
  • SaaS applications. Hosted and run by a vendor. They sit outside this front door, and the diagram highlights why (see below).

Every application that goes through the front door is assigned to exactly one lane before anything is provisioned.


Three kinds of applications. The lane is chosen first for the two on the left; SaaS, highlighted, stays outside.

 

Lane A: you are not reviewing code, you are choosing whom to trust. The questions move from the source to the supply chain: where it comes from, what is known to be wrong with it, who keeps it current, what its licence obliges you to do. The answer is one of three, each with its reason on record: adopt, adopt with conditions, or decline. Teams are entitled to a clear decision, including a clear no, and to get it fast.

Lane B: the code is ours, so the controls focus on what happens to it: automatic checks before every build, a tested version that becomes the released version, and sign-off by the people who answer for the application.

SaaS: you have no control beyond assessing the supplier. You check that their offer matches your own expectations and governance rules, and you rely on the binding contract you have signed with them.

Why SaaS stays outside

SaaS is the third kind of application at the door, and the one most easily forgotten. Such applications often enjoy an open door to our back end through single sign-on, automated provisioning and every other data exchange we consent to, which lets them harvest corporate data and use it later. We keep them out of this front door for three reasons: they are not hosted by corporate IT, IT has no access to their code, and a subscription means contractual obligations: the provider is in charge of hosting, but also of the security and compliance of their solution. They deserve their own answer, through contracts and data-sharing reviews rather than pipelines.

One application, one project

One application = one dedicated delivery project (from a code hosting and underlying infrastructure perspective). Never two in one, never one split over several.

This single rule implies a lot of work. Access, ownership, audit trail and cost all follow when an application has one home that belongs to it alone, and every application must have a named business owner and a named technical owner. Responsibilities of these people must have been clearly explicited ahead as they will play a key role laterin the lifecycle management of these applications.

What one new application really needs

Before the first deployment, even a small application needs a surprising amount of plumbing. Each item is simple on its own; together they are what keeps a prototype from becoming production. Before talking about hosting at corporate scale, here is the foundation every application must demonstrate and respect:

  • An identity and an owner. Who can reach it, who answers for it, who is told when something breaks.
  • A home for the code, with history, review and protected branches.
  • A way to be built, the same way every time, with checks along the road.
  • A place to run, with its own address, secrets kept out of the code, and least-privilege access.
  • A way to be watched, so the right people hear about a problem before the users do.
  • A lot of security considerations. The underlying infrastructure must be deployed in line with the corporate security concept.
  • A lot of governance. Every component deployed for the points above must respect the standards, so that users cannot do more than they requested and require, which could introduce security breaches and make costs uncontrollable.

A rule in a document gets bypassed

A rule that lives in a document gets bypassed. A rule that lives in automation gets followed.

Humans cannot be trusted to respect guidelines, even less when those are written. They are never read. This is even truer with vibe coding, where the people building mostly do not have the knowledge to build for production. That creates a strong requirement: the end-to-end build process must be guard-railed and automated, and that in turn implies standardised architectures.

So every policy had to pass one test: can a machine apply it? Rules became checks that run on every change, in the same order, with the same result for everyone.

The Lane B path: the same for every application, whoever builds it. Lane A follow a similar but lighter path.

  • Quality, security and vulnerability checks before anything is built. Code that has not passed them never becomes a package. The list is open by design: new controls, such as proof that the documentation was updated with the change, can be added once and apply to every application.
  • Delivery is idempotent: the version tested is the version released. The exact package that was tested is the one promoted to the next stage, never a rebuild that merely looks the same. Run the same delivery twice and you get the same result, which makes every release repeatable and explainable.
  • Application owners and business owners decide, and are empowered to. The people who answer for an application approve its release after a real acceptance test; those who write the code do not sign off on themselves. The aim is, after the latest release of the application has been pushed into production, the end of the "we have a P1, the application stopped working" call, which in practice almost always traces back to acceptance testing that was never properly done.
  • Every release is verified, and the right people are engaged at once. A battery of tests runs at each stage to confirm nothing was broken, followed by deep release monitoring and alerting, so that whoever is in charge is called as soon as it is needed, not once users complain.

Provisioning without the queue

A home for a new application used to mean a tens of requests to a multiple teams in charge of their own areas, each with its own form, its own delay and its own interpretation of the rules. We replaced that with a short series of automated procedures, built on a very standardised but still flexible architecture. Each does one job, and each is run by the application platform team, in minutes rather than weeks:

  1. Identities and access. The groups that say who may develop, approve, administer and access this application, and the application's own identities, created with their owners named and verified.
  2. A home for the code. A dedicated delivery project with its repository, a protected main branch, mandatory review, and the rule that nothing reaches it without passing the checks.
  3. The runtime. A set of standard resources respecting the governance rules, the containers for each tier of the application, and, when it needs one, its database, reachable only from inside the private network.
  4. The delivery pipelines. Build, test, release to the acceptance environment, release to production, each wired to the shared rules and to the approval gates held by the application and business owners. All these pipelines are managed by the application platform team.
  5. Least-privilege permissions. Each pipeline and each container receives exactly the access it needs, and nothing more: pull its own image, read its own secrets, deploy to its own environment.
  6. The publication of the application. The name registered, the certificate in place, and the entry point that publishes the application to its users, always through the controlled gateway, which enforces security at the same time.

The output of each step feeds the next. The application's name, its lane and its structure are captured once and carried through, so the person provisioning confirms rather than retypes, and can still change any choice. What used to be a queue of tickets becomes a single guided session, and the result is identical for every application: same naming, same guard-rails, same layout.

Every environment provisonning procedure keeps the same contract:

  • Preview first. It shows its whole plan before changing anything, so the application platform team can identify any deviation from the standards and adapt it before the systems are altered.
  • Safe to repeat. A second run finds nothing left to do and will never overwrite what alreadyexists, which lets the platform team quickly identify any adaptation that may be required.
  • Proof, not promises. Every run leaves an evidence record, with no secrets in it, that an auditor can read months later.

With that, the end-to-end environment is provisioned within minutes, in a fully standardised way: each application benefits from the very same underlying platform as its siblings.

Pipelines are the only road to buid an application, and they belong to the platform

No application is ever built or released by hand.

The entire build and control process relies on pipelines that remain under the authority of the application platform owners. Nobody else can alter them, and no change to them takes effect without the platform owners' approval and confirmation. Developers use the pipelines and can ask for adaptations if needed. They, however, can never edit them.

Everything is triggered by events: a change submitted, a change accepted, a release approved. The same pipelines run every time, which is what makes the controls trustworthy.

It also changes who can build. People without development or infrastructure skills (vibe coders) can still create their applications, because the platform carries the burden of building, securing, hosting and releasing them. They meet the corporate expectations by construction, not by expertise.

Fix it once, fix it everywhere

As applications multiply, a quiet risk grows: the delivery logic gets copied into every project and every copy may drift. A fix then has to travel to dozens of places, with the risk it never reches some. Our answer is to hold the delivery rules once, in a place application teams can use but cannot change. What an application says about itself, how many parts it has and how to build them, is a small file its team owns. Everything else is shared.

Rules are held once. Each team owns only the facts about its own application.

An application can be a single service or a small family of them, published to the web or running quietly in the background. The platform adapts instead of asking for exceptions, and a change to a rule is tried on a test application first, then reaches every other application at once.

Standards, not lock-in

The architecture underneath is deliberately standard. Applications are packaged as standard container images (the open OCI and Docker image formats), and everything around them is designed to treat that package as the unit of delivery. The consequence is portability: the same initiative can move to any hosting provider, platform or technology that supports these standards. We standardise the architecture, not the vendor.

Lessons from the field

We did not design this on a whiteboard alone. We ran it against a real environment, and it corrected us several times:

  • Plan for what security will actually allow, not for what the tutorial shows. Many organisations block the quick ways for scripts to sign in.
  • Fewer dependencies beat clever ones. Several versions of the same tooling side by side can break a script that worked yesterday.
  • A preview that skips half the checks is false comfort. The preview and the real run must reach the same conclusions.
  • Be honest about what is proven. We label what has run for real and what has not. It builds more trust than a polished claim.

Where we are today

The standard for both lanes is defined. The full automation, from provisioning to the pipelines that build and release every application, is built. We are moving from the design bench to first real deployments, with a dedicated test application proving each new piece before it is trusted and the first production application are also in the process of being deployed. The longer-term ambition is a single front door where teams find the guidance, see the details of their own application, and receive everything they need once their environment is ready. We will also investigate additional flexibility, so that the lightest applications, such as non-web applications or scripts, can be onboarded in this model as a standard Lane B application. Lifecycle management and regular, automated security investigations (and responses) will be part of the picture.

Who is behind this?

This approach was not put together by a software developer. It comes from an engineer with a background in cloud architecture, infrastructure and security. That is why it starts from the questions a developer rarely asks first: who is allowed to do this, what can go wrong, what will the auditor want to see, and what happens when the person who built it leaves? When anyone can produce code, the scarce skill is deciding what the code may do, where it may run and who answers for it.

Ready for the next prototype at your door? We have designed and built this approach end to end: the rules that decide what may go live, a standard container-based architecture, and the automation that provisions and releases every application the same way, with proof an auditor can read. It is vendor-neutral and portable, and it lets people without development skills deliver applications that meet your corporate expectations.

Want to see how it would fit your organisation? Get in touch for a conversation or a walkthrough.