Back to the blog

Vibe coding a business app: 11 things to get right

Accounts, roles, logs, backups, a test instance, rollback and 5 more things an app built with an AI agent needs before your team starts using it.

Drubricks··7 min read

You have an order-tracking app built with an AI agent. It works, it saves data, your business partner has seen it. Now you want the team to use it, and the questions start: who changed what, what if the server goes down, how do you ship a fix without interrupting anyone’s work.

Before real data goes in, check 11 things: user accounts, roles and permissions, logs, a database, backups, a test instance, a way to update, rollback, maintenance mode, uptime monitoring and languages. Do the first four right away. Permissions have to be checked on every screen and every query, logs can’t be added after the fact, and data kept in a file will have to be moved into a database later anyway.

By a business app we mean a system that several or a dozen people use every day and that holds the company’s data: customers, orders, invoices, schedules. If you are the only user, part of this list can wait.

Who did what: accounts, roles and logs

1. User accounts: everyone signs in as themselves

One shared password is fine for a demo. In a company it blocks everything else on this list: you can’t assign permissions, you can’t see in the logs who deleted an invoice, and you can’t cut off someone who leaves.

Check that the app has separate accounts with password reset, that an account can be blocked without deleting that person’s data, and that every record stores who created it and who changed it last.

2. Roles and permissions, checked on the server

A role says what a person may do. In a language school a teacher sees their own lessons, the office sees all of them, and accounting sees payments. Permissions have to be checked on the server. A hidden button protects nothing if the URL or the API hands the data to anyone who is logged in.

In the OWASP Top 10:2025, broken access control is in first place, and some form of it was found in 100% of the applications tested.

Ask the agent for a table: roles in rows, record types in columns, and in each cell who may read, create, change and delete. Then ask for tests that sign in as each role and check what that role must not see.

3. Logs: what happened, when, and who did it

You need two kinds of logs. Error logs tell you what broke. An audit log tells you who did what: who signed in, whose sign-in failed, who changed or deleted a record. OWASP says plainly that without logging and monitoring, breaches cannot be detected, and lists logins, failed logins and high-value transactions as events to record.

Turn both on from day one and ask the agent to make every audit log entry say who did what, when, and to which record.

Data that survives a failure

4. A database, not a file or the browser’s storage

Prototypes often keep data wherever was quickest: a JSON file, the browser’s storage, or a database on a container disk that disappears with the next deployment. In a company the data goes into a database (MySQL, MariaDB, PostgreSQL), and changes to its structure are made with migrations: scripts the new version of the app runs on the existing data.

Ask the agent directly where the app stores data and what happens to it on the next deployment.

5. Backups that someone has restored

We recommend an automatic backup of the database and files (attachments, photos) at least once a day, and at least one copy off the app’s server, for example with another provider. Every now and then, restore a backup on a separate machine. Only after such a test do you know how long recovery takes and whether the backup is complete.

Changes without stopping the team

6. A test instance with its own database

A test instance (staging) is a copy of the app with the same code but its own database and its own data. The agent deploys changes there first, and you click through a new feature there before the team sees it. Its data should be demo data or anonymised, because such an environment is usually watched less closely than production.

7. One way to update

An update covers new code, database migrations, new library versions and the framework’s security fixes. You need one repeatable way to deploy: from a git repository, with one command or through CI (an automated pipeline that runs tests and deploys after every change in the repository), with migrations run automatically. Copying files over FTP and fixing the database by hand end with nobody knowing what is on the server.

Ask the agent which framework and libraries the app is built on. Then decide who follows their security announcements and how often they upgrade them.

8. Rollback when a deployment fails

Before you deploy a change, decide how you will get back to the previous version: the previous commit (a saved version of the code in git), the previous container image (if the app runs in Docker), a database backup taken just before the migration. Database changes are the hardest to undo. You can restore code with one command, but not a column a migration has dropped, which is why we back up the database before every deployment with a migration.

9. Maintenance mode while you work

During an update or a fix, users should see a notice about the work, not errors and half-saved forms. Administrators keep using the app in the meantime and check that everything works. That is how maintenance mode in Drupal works, for example: people with the right permission use the site, everyone else sees a maintenance message.

Is the app up, and does it speak your team’s language?

10. Uptime monitoring: you hear about an outage before the team does

Uptime monitoring checks every few minutes whether the app responds and sends an alert when it stops. Without it you hear about an outage from someone who has not been able to issue an invoice for an hour. An external monitoring service that checks the app from a different network than your server, plus a notification on your phone, is enough.

11. Languages, if the company works in several countries

If the interface texts are hard-coded, adding a second language means going through every screen. When the company has, or will have, staff or customers in other countries, ask the agent from the start for interface translations and for date, number and currency formats that follow the language. Content that users type in is a separate decision: whether a product description needs several language versions has to be settled before the data model is built.

Where do you start if you can’t do it all at once?

With the order. Set up accounts, roles, logs and the database before real data goes into the app. Set up backups, the test instance, the update process, rollback, maintenance mode and monitoring before the first deployment the team works on. Languages depend on the company.

The first step is an audit. Paste this prompt into your agent and read the report before it changes anything:

Review this app for use in a company. Answer point by point, naming the files,
and don't change anything yet:
1. Does every user have their own account, and can it be blocked?
2. What roles are there, and are permissions checked on the server for every record type?
3. What is logged: errors, sign-ins, changes and deletions of records?
4. Where is data stored, and how does the database structure change?
5. How do we back up the database and files, and how do we restore them?
6. Is there a test instance with its own database?
7. How do we deploy a new version, and how do we update dependencies?
8. How do we get back to the previous version if a deployment fails?
9. Is there a maintenance mode for when we work on the app?
10. Who finds out that the app is down, and how?
11. Can the interface be translated without code changes?

The report shows what is missing. Fill the gaps in the same order, and after each point ask the agent for a test that checks it.

We build Drubricks, a free Drupal starter for business apps built with an AI agent: it has accounts, roles, permissions on individual records, logs of record and configuration changes, maintenance mode and an interface in 100+ languages from day one, while backups, monitoring and the test instance you set up with your hosting. If you already have a prototype, you can give it to the agent as the description of the system to build on the starter.