> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lovable.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Workspace policies

> Set Enterprise policies that block publishing or require approval for public apps, connectors, and Lovable backend services, and let editors request connectors.

**Workspace policies** control when an app in your workspace can be published, and when a project can enable Lovable backend services. One policy also lets editors request connectors. A publishing or backend policy either blocks the action for the projects it applies to, or requires a workspace admin or owner to approve it first. When no policy applies, Lovable publishes the app or enables the backend without a review.

A policy checks the person's workspace role, not their role on the project.

These are the policies your workspace can have:

* [Restrict publishing with unresolved sensitive data findings](#restrict-publishing-with-unresolved-sensitive-data-findings): block or review publishing while a project has unresolved findings of personal data.
* [Restrict publishing by external collaborators](#restrict-publishing-by-external-collaborators): block or review publishing by people invited from outside your workspace.
* [Restrict publishing externally](#restrict-publishing-externally): block or review publishing that makes an app public.
* [Require approval to publish apps that use connectors](#require-approval-to-publish-apps-that-use-connectors): review apps that connect to other services before they go live.
* [Connector requests](#connector-requests): let workspace editors ask for a connector that is disabled in your workspace or that only admins and owners can connect.
* [Restrict Lovable backend services](#restrict-lovable-backend-services): review a project before it enables Lovable's built-in backend.

Workspace admins and owners skip these policies, except **Restrict publishing with unresolved sensitive data findings**, which applies to everyone. Under **Restrict publishing externally**, a workspace owner can choose **Owners only**, and then the policy applies to admins too.

You cannot write your own conditions, choose different approvers, or send requests to specific people.

**Workspace policies** are available on the Enterprise plan. Workspace admins and owners manage the publishing policies in the **Publishing policies** section of [Workspace settings → Security → Privacy & security](https://lovable.dev/settings/privacy-security#publishing-policies). **Restrict Lovable backend services** sits in the **Data protection** section of the same page, and **Connector requests** in the **Connector policies** section of the **Integrations** tab.

> [!NOTE]
>
> A policy only adds a restriction, except **Connector requests**, which lets editors ask for a connector. No policy lets anyone use something they could not use before, and no policy changes anyone's project or workspace role. The other settings in the **Publishing** section of **Privacy & security**, such as **Block publishing with critical issues**, keep working alongside the policies.

## Enable a policy

Each publishing policy has its own row in **Publishing policies**, with a switch and a **Configure** button. **Connector requests** and **Restrict Lovable backend services** are set up differently, as described under [Connector requests](#connector-requests) and [Restrict Lovable backend services](#restrict-lovable-backend-services).

**1. Open Publishing policies**

Open [Publishing policies](https://lovable.dev/settings/privacy-security#publishing-policies) in **Privacy & security**.

**2. Configure the policy**

Select **Configure** to open the policy's dialog. Enabling the switch on the row opens the same dialog, so nothing is saved until you select **Turn on** there. Most policies have one decision to make, described under each policy below.

**3. Read the summary**

In **Require approval** mode, the summary in the dialog shows what changes for the people who publish. For the connectors and external collaborators policies, the summary also counts how often the policy would have required approval in the last 30 days. The count shows how much review work you are about to create.

**4. Enable the policy**

Select **Turn on**. The row shows the policy as enabled.

The dialog also shows two facts that are the same for every approval policy. Every workspace admin and owner receives each request in Lovable and by email, and any one of them can approve or deny it.

The dialog also shows how long requests stay open, under **Requests expire after**: 30 days for every policy. A request nobody approves or denies in that time counts as denied, and the action it asked for does not happen.

Policies have no test mode. To try a policy that has both modes, enable it in **Require approval** mode first and watch the requests before you switch it to **Block**.

Lovable records every policy change, every time a policy checks an action, and every approval or denial in the [audit logs](https://docs.lovable.dev/features/audit-logs.md).

## Restrict publishing with unresolved sensitive data findings

The policy applies when a project has unresolved findings from [Sensitive data scanning](https://docs.lovable.dev/features/sensitive-data-scanning.md). **Sensitive data scanning** is Lovable's scan for personally identifiable information (PII), such as names, emails, and identity numbers, in a project's data and chat. A finding is one piece of personal data the scan recorded.

The policy needs the [Sensitive data scanning](https://docs.lovable.dev/features/privacy-and-security-settings.md#sensitive-data-scanning) setting enabled and saved first. Until then you cannot enable the policy.

The policy applies to everyone, including workspace admins and owners.

Choose what happens when someone wants to publish an app with unresolved findings:

* **Block**, the default: Lovable refuses to publish, and the person publishing sees the findings that block it. They can publish after the findings are resolved.
* **Require approval**: publishing waits for a workspace admin or owner. Choose this when an approver should be able to approve an app after checking the findings, for example test data that scanning flagged.

An approval has no time limit. It ends when the number of unresolved sensitive data findings changes or when who can view the app changes.

## Restrict publishing by external collaborators

The policy applies when the person publishing is an external collaborator, a person outside your workspace who was invited to a project, such as a contractor or agency staff member. Workspace admins and owners are exempt.

Choose what happens when an external collaborator wants to publish:

* **Block**: Lovable refuses to publish, and the external collaborator sees that a workspace policy blocks publishing. Choose this when people outside your workspace build apps, and only your members publish them.
* **Require approval**, the default: publishing waits until a workspace admin or owner approves it. Choose this when external collaborators should publish their apps after a check.

An approval has no time limit. It ends when the person's role in your workspace changes or when who can view the app changes.

If your workspace does not allow external collaborators on projects, the policy never applies. See [External project collaborators](https://docs.lovable.dev/features/privacy-and-security-settings.md#external-project-collaborators).

## Restrict publishing externally

The policy applies when an app is published publicly, meaning anyone with the link can open it. It covers updates to an app that is already public. It does not apply to publishing to your workspace or to selected people.

Choose who publishes public apps without a request, under **Who publishes without approval**: **Owners and admins**, or **Owners only**. Only workspace owners can choose **Owners only**. In **Block** mode the same choice is labeled **Who can publish externally**, and it sets who can publish publicly at all.

Workspace owners are always exempt from this policy, in both modes. Workspace admins are exempt too, unless you choose **Owners only**.

Choose what happens when anyone else wants to publish a public app:

* **Block**: only the roles you chose publish publicly. Choose this when publishing publicly should stay with those roles, for example while a security review runs.
* **Require approval**, the default: publishing waits until a workspace admin or owner approves it. Choose this when most apps should go public after a check. You get a record of who approved each public app.

Set how long an approval lasts under **Approval lasts**: 14 days by default, from 1 hour to 30 days. During that time the person publishes the public app again without a new request. This is the only publishing policy whose approval expires on its own.

## Require approval to publish apps that use connectors

The policy applies when the project uses one or more [connectors](https://docs.lovable.dev/integrations/app-connectors.md), for example a Snowflake, HubSpot, or Stripe connection. An app with a connector moves data from a system your company controls, so a workspace admin or owner reviews the app before it goes live.

Workspace admins and owners are exempt. The policy has one mode, **Require approval**.

Choose which connectors count under **Connector types**:

* **All connector types**: every connector counts.
* [App + chat connectors](https://docs.lovable.dev/integrations/app-connectors.md): connectors that use one shared workspace account.
* [App user connectors](https://docs.lovable.dev/integrations/app-user-connectors.md): connectors where each app user signs in with their own account.

An approval has no time limit. It ends when the app's connectors change or when who can view the app changes.

## Connector requests

The **Connector requests** policy lets workspace editors ask for a connector they cannot connect. An editor can request a connector that is disabled in your workspace. An editor can also request one that only workspace admins and owners can connect, when the editor cannot use any existing connection. Admins and owners set both in **Connectors → Admin settings**, as described in [Manage connectors in your workspace](https://docs.lovable.dev/integrations/admin-controls.md#who-can-create-connections-and-clients). The policy is disabled by default.

Workspace admins and owners enable or disable the policy with its switch in the **Connector policies** section of [Workspace settings → Security → Privacy & security → Integrations](https://lovable.dev/settings/privacy-security#mcp-connectors). The policy has no mode to choose and no **Configure** dialog.

With the policy enabled, an editor requests a connector from:

* the connector's page in **Connectors**, where a request button, for example **Request Slack**, replaces **Connect**. The editor can add an optional note of up to 200 characters about what they need the connector for.
* the project chat or [Chats](https://docs.lovable.dev/features/chats.md), when Lovable offers a connector for something the editor pasted, such as a link or an API key. The request takes one click and has no note.

Workspace admins and owners do not send requests. They set the connector up themselves.

Requests appear in the [Action center](https://docs.lovable.dev/features/action-center.md#connector-requests), where an admin or owner sets the connector up or declines the request. Lovable does not email admins about new requests, so check the Action center for them. Lovable removes a request from the Action center after 30 days.

When the connector becomes available to the editors who asked, they get a notification in Lovable. Lovable also notifies them when an admin declines the request, and includes the reason if the admin gave one. After an admin declines, the editors can request the connector again.

## Restrict Lovable backend services

The policy applies when someone enables **Lovable backend services** in a project. **Lovable backend services** is the [built-in backend](https://docs.lovable.dev/features/cloud) Lovable runs for an app, where its database, user accounts, and file storage live. A workspace admin or owner approves each project, so you can keep track of which projects store data with Lovable.

Lovable sets this policy up for your workspace and enables it at the same time. Ask your Lovable account team to have it set up. After that, workspace admins and owners manage it in the **Data protection** section of [Workspace settings → Security → Privacy & security](https://lovable.dev/settings/privacy-security#data-protection), where they can disable it and enable it again.

Workspace admins and owners are exempt. They enable backend services in a project without sending a request. Lovable offers one mode for this policy, **Require approval**.

A member who asks Lovable for something that needs a backend sees an approval card in the project chat instead. The backend stays off until an approver agrees. The member selects **Request approval**, adds an optional message, and selects **Send request**.

Requests come from the project's main chat, because Lovable cannot enable a backend inside a [draft](https://docs.lovable.dev/features/drafts.md). The card also shows the [region](https://docs.lovable.dev/features/cloud#choose-where-your-project-data-is-stored) the backend will run in. The member can change it, unless an admin set a default data hosting region for the workspace.

Each approval covers one project. Lovable enables backend services as soon as an approver agrees, whether or not the requester still has the project open. A second project needs a new request.

After a workspace admin or owner denies the request, the backend stays off and the requester sees the reason in the project chat. Asking Lovable for the same thing again opens a new request.

## How approvals work

A publishing policy applies to every way an app can be published, including from the project chat. When a policy requires approval for publishing from the project chat, Lovable replies that approvers were notified and that it publishes the app when one of them approves. **Restrict Lovable backend services** replies the same way, and enables the backend when an approver agrees.

Workspace admins and owners approve or deny requests in the [Action center](https://docs.lovable.dev/features/action-center.md#approve-or-deny-a-request). A workspace admin or owner cannot approve their own publish request, so another workspace admin or owner approves or denies it. When a request can only go to the person who sent it, they approve or deny it themselves.

The person who publishes follows the request in the publish dialog, described in [Request approval to publish](https://docs.lovable.dev/features/publish.md#request-approval-to-publish). A member who asked to enable backend services follows it on the approval card in the project chat.

Under a publishing policy, an approval covers the app, not a single version. After a workspace admin or owner approves a request, Lovable publishes the app. The requester then publishes later updates of the same app without a new request.

The approval ends when something the policy checks changes. For the **Restrict publishing externally** policy, it also ends when the time set under **Approval lasts** runs out. The requester then requests approval again.

People keep editing and previewing the app while a publish or backend services request waits.

More than one policy can apply to the same app. The requester sends one request and the approver sees one item for all of them. Lovable publishes the app when the item is approved.

A waiting request is closed without a decision when something the policy checks changes:

* the project's connectors,
* who can view the app,
* the number of unresolved sensitive data findings,
* the requester's role in the workspace, or
* the project moving to another workspace.

Approvers see a closed request as **Expired · project changed** the next time they open the **Action center**. The requester can request again for the current state of the app.

A publicly published project cannot be moved into a workspace whose **Restrict publishing externally** policy applies to the person moving it. Unpublish the project first, or ask an admin or owner of the destination workspace to move it.

## Change or disable a policy

Each policy row shows how many requests are waiting, for example **3 requests waiting**, with a link to the **Action center**, so you can see what a change affects before you make it.

To disable a publishing policy, open its dialog, disable it there, and confirm. To disable **Connector requests**, disable its switch in **Connector policies**, as described under [Connector requests](#connector-requests).

> [!WARNING]
>
> Three changes cancel every waiting request:
>
> * You switch a policy from **Require approval** to **Block**. From then on, Lovable refuses to publish the apps the policy applies to.
> * You disable a policy. People then publish, or enable a backend, without review. Disabling **Restrict publishing externally** also lets everyone with publish access publish publicly.
> * You change the connector types of the **Require approval to publish apps that use connectors** policy. The dialog shows no warning for this change.
>
> Lovable does not approve the waiting requests for you.

A change to **Approval lasts** does not cancel waiting requests. The new duration applies to requests opened after you save it.
