The fact that an app built by a non-developer works smoothly can actually delay the discovery of a serious risk. If database connections and deployments remain active after the owner changes or leaves the company, the app will continue to run, but the organization may not know who owns it or where to recover it. In practice, internal app management should begin by creating an official deployment path that can be operated, not by blocking creation tools.
In one real-world case, the marketing team contacted the engineering team about a dashboard that had stopped updating, but the engineers did not know the app existed. It had been built with Lovable, used a Supabase service key, and was deployed to a personal Vercel account. Its creator had already left the company. The app was still running, but for all intents and purposes, it had disappeared from the organization’s management system.
Why an App List Alone Is Not Enough
Personal-account deployments, fragmented databases, and long-lived service keys collectively create gaps in internal app management across different tools. Blocking only one tool merely encourages teams to move to another service. Prohibiting personal accounts without providing organizational accounts and a shared deployment path will likewise lead teams to find workarounds. Even registering an app’s name does not address database permissions, secrets, incident alerts, or recovery responsibilities.
Therefore, code created with AI generation tools should be treated as code submitted through an approved pipeline. More important than the author or the tool used is the account from which the code is deployed, the data it can access, and who responds when it fails. Without this principle, every new generation tool adds another asset beyond the organization’s control.
First Step: Establish a Controllable Deployment Path
Managed apps should be organized under organizational accounts with team permissions, and projects created in personal accounts should be transferred to organizational projects. Deployment should occur through a shared CI/CD pipeline after code changes, tests, security scans, and database migration reviews and approvals. Build artifacts and deployment metadata should include an app identifier and owner information, making it possible to find the same details later during recovery or decommissioning.
The CLI can first be used to identify which projects remain under the current account. The following commands are conceptual examples, and actual output will vary depending on account status.
vercel projects ls
vercel teams ls
supabase projects list
※ Note: The following configuration and code are conceptual simulation examples (Illustrative Example, not official spec).
Projects discovered in personal accounts should be checked for continued use and then transferred to organizational projects. Once the transfer is complete, existing deployments and data connections should be linked to the official asset inventory, and personal-account tokens should be revoked. Rather than applying blocking commands first, organizations should provide secure defaults, cost controls, and support channels so teams can choose the official path in practice.
Second Step: Attach Responsibilities to the App Inventory
An internal app inventory should record at least the app name, business purpose, users, data store, deployment account, creator, current owner, incident contact, secret storage location, backup and recovery method, and decommission status. Separating the business owner from the technical owner does not solve the problem. The business owner should determine priorities and intended use, while the technical owner is responsible for recovery and changes.
Binding ownership and operational responsibility to an individual author creates a gap whenever that person changes roles. Departure events should trigger the revocation of SSO sessions, team memberships, API tokens, and database permissions. Handover procedures should include a test in which the replacement owner confirms receipt of real incident alerts. An empty mailing list is only an archive for notifications, not a substitute contact network.
Third Step: Combine Secrets and Incident Response in One Loop
Supabase service keys should never be left in personal environments or documents. They should be moved to a central secret manager and replaced with workload identities and short-lived credentials. Database permissions should separate read and write access, while deployment accounts should be reconciled regularly against the app inventory to remove unused keys and orphaned credentials.
Monitoring should go beyond simple uptime checks. It should detect authentication errors, interrupted data updates, and backup failures, with alerts routed through existing on-call and ticketing systems. The app registry should record repository, deployment, data_store, monitoring_contact, lifecycle_status, and decommission_date so incidents, changes, and decommissioning remain connected in one workflow.
A decommissioning process is also necessary. Based on business closure or the criteria for last use, the app’s status should be changed to retired, and deployments, DNS, data, secrets, and external integrations should each be reclaimed. Revoking database permissions while leaving data and configurations behind makes an inoperable app continue to appear as a managed asset. Conversely, blanket restrictions on AI tools do not solve the problem.
The origin of this problem is also reflected in the original discussion. The original thread, which asks whether platform owners can inventory internal apps and who will detect and recover them during an incident, shows that the management gap has already become a real operational issue.
Operating Principles Matter More Than Avoiding Anti-Patterns
The most common failure is to create an app list without assigning an operational owner. The next failure is leaving service keys in plaintext or revoking only deployment and database access when an employee leaves. If personal accounts are prohibited without an official path, users will scatter across external SaaS platforms. Organizations should first provide secure organizational accounts and a shared pipeline.
Implementation will inevitably require organizations to align cost allocation, SSO integrations, and cross-team approval criteria. Rather than abandoning controls, the practical approach is to move higher-risk assets to organizational accounts first and repeatedly test approval procedures and credential revocation. Internal app management does not end with counting generated code. It is an ongoing operational practice that keeps assets, data, deployments, secrets, and incident responsibilities connected.
An initial review can begin by comparing the deployment platform’s project list and database list with the app inventory. Projects remaining in personal accounts should be checked for use and transferred to organizational projects, while apps with unclear ownership should be assigned both a business owner and a technical owner. Service keys stored in personal environments should be moved to a central secret management system and replaced with workload identities and short-lived credentials. Deployment, authentication, data update, and backup status should be monitored through a single on-call path and confirmed directly by the replacement owner. When an employee leaves or a business closes, account sessions, API tokens, database permissions, DNS, data, and secrets should be reclaimed together.
Practical Implementation Points
- Coordinate with relevant teams and confirm the approval path
- Test potential impact in an isolated environment beforehand
- Establish a phased rollout and emergency rollback plan
Source
This article was prepared by reviewing the following original source: r/devops — How many apps have non-engineers at your company built with Claude/Cursor/Lovable, and who owns them when they break?

Leave a Reply