How To Add Integrations To Lovable Apps: A Step-By-Step Guide With Membrane

Lovable.dev is a delightful and powerful AI coding agent that can generate modern, usable sites and apps in minutes. Its strength lies in fast and effective scaffolding: interactive dashboards, polished UIs, and smooth user experiences.

But if you’ve ever asked Lovable to build an end-to-end integration, you’ll know it looks amazing, but can struggle to connect reliably to external services.

Integrations aren’t fault-tolerant.

They require reliable authentication, solid integration logic, and secure execution routes. That’s where Membrane comes in: the AI-native universal integration layer that allows you to build connections to any app, for any use case.

A Practical Experiment

Let’s ask Lovable to create a scaffolded SaaS platform dashboard that allows users to connect their own HubSpot and OpenAI accounts, and generate a Smart To-Do list from their HubSpot Tasks.

Here’s the initial prompt to Lovable:

Create a SaaS dashboard with a “Connect to Hubspot” button, a “Connect to OpenAI” button, and a way for users to fetch their Hubspot tasks and process them with OpenAI in order to produce a prioritized to-do list.

The Results: What Lovable Does Really Well (On Its Own):

Generates a slick UI with connection buttons:
Prompts us to connect Supabase for a backend (which our use case would require):

Generates a scaffolded, API-based infrastructure after referencing the relevant OpenAI and Hubspot docs:

Where It Could Use Some Help:

Lovable asked for my personal OpenAI API key, which doesn’t make sense for our use case. We want this app to let any user connect their own accounts.
It generated brittle, custom OAuth flows, which would have leaked tokens in client state (if they had worked).
The system lacked reliable integration logic. It was designed with one-off API fetches that, even if working, would not have allowed retries, multiple users, or secure action execution.

Result: The app looked great, but the integrations didn’t work end-to-end.

Adding Membrane to the Mix

To help Lovable vibe its way to a fully-integrated app, we introduce Membrane.

Here’s how:

Feed Lovable the Membrane AI Context

We pasted Membrane’s Initial AI Context directly into the conversation. This gave Lovable knowledge of Membrane’s integration framework: connection UIs, connectors, authentication tokens, etc:

Leverage Membrane’s Connection UI

Instead of trying to scaffold its own interface for user connections, Lovable was nudged to use Membrane’s pre-built Connection UI, which automatically handles OAuth, token storage, and user-specific authentication:
Implement Supabase Backend

Pasting the Membrane AI Quickstart Context also taught Lovable how to configure Supabase to support Membrane’s backend requirements.

Lovable asked for my Membrane credentials and stored them as Secrets to be retrieved by Supabase Edge Functions. Now, when prospective users want to connect their accounts for HubSpot and OpenAI, the system will create Membrane connections that are authenticated with my workspace credentials:

Configure the Membrane Workspace

Since Lovable doesn’t currently support connecting to Membrane in a local dev environment, we manually:

Added HubSpot and OpenAI connectors through the Membrane console, which only takes a few clicks.
Configured the relevant Actions (fetch-tasks, summarize-tasks).
Grabbed the drop-in SDK calls from the console. Membrane provides exact code snippets that you can drop into your app for Action execution:

Provide Lovable with the SDK Calls

We pasted the Membrane Action snippets into Lovable so that it could wire up backend calls correctly:
Troubleshoot with “Vibes”

If Lovable became confused (which can be expected within the vibe-coding experience), we reminded it of two truths:

Remember that Supabase handles backend auth & token persistence, and users connect their own accounts. Never ask for my individual API keys for HubSpot or OpenAI.
The Membrane AI context is the source of truth for connections & actions.

Experiment Result:

After Lovable elegantly vibe-squashed a couple of runtime errors, the app worked! Integrated end-to-end and reproducible:

The app features a fully-integrated workflow, allowing users to:
Connect to their own OpenAI and Hubspot accounts with Membrane’s Connection UI components.
Generate an AI-optimized, smart to-do list
Navigate a sleek, interactive UI.

The only manual steps required were adding connectors in the Membrane workspace and configuring Membrane Actions — each of which required just a few clicks.

The Difference with Membrane

Membrane turned Lovable from a UI wizard into a production-ready integrations builder:

Auth flows: No more individually managing API keys. Users can connect their own HubSpot and OpenAI accounts, and connections are handled securely by Membrane.
Actions: Instead of brittle one-off fetches, Membrane Actions provided reusable, reliable integration logic.
Supabase + Membrane: Secure, multi-tenant backend without reinventing the wheel.

Now, when a user connects HubSpot and OpenAI, the app reliably fetches tasks, summarizes them, and provides a secure, user-specific to-do list.

Experiment Analysis

Scaling the Vibe

The value of Lovable is in fast iteration and beautiful UIs. The value of Membrane lies in its reliable and scalable integrations.

Together, they vibe into something greater:

Developers can sketch ideas at the speed of thought with Lovable.
Membrane ensures those ideas actually work across any SaaS app.

Bottom Line: With Membrane in the loop, Lovable doesn’t stop at ideation and starts being a true SaaS integrations builder.

Start building integrations today. Try Membrane:

Try Membrane
Membrane docs
Explore Lovable