Backend for your vibe coded apps

Build powerful backend automations for your Lovable apps with Meerkats AI. No coding required. Follow this complete guide to connect Supabase workflows easily.

Add Backend Automation to Your Lovable Apps Without Writing Code

If you're building apps with Lovable (vibe coding), you've probably hit a wall when trying to add backend logic. Email automations? Database triggers? User onboarding flows? These all require backend functionality that can slow you down—or force you to learn backend development.

That's where Meerkats AI comes in.

Meerkats AI is a backend automation platform built specifically for vibe coders who use tools like Lovable. It connects directly to your Supabase database and lets you build powerful workflows without touching backend code.

TLDR: Watch this video to see how to connect lovable cloud with meerkats AI and run automations.

The Backend Problem in Vibe Coding

When you're building with Lovable, the frontend comes together incredibly fast. You can create beautiful, functional user interfaces in minutes using natural language prompts. But what happens when you need to:

Send welcome emails when users sign up
Trigger actions based on database changes
Set up conversion funnels and user journeys
Automate repetitive tasks
Track user behavior and engagement

Traditionally, you'd need to:

Learn serverless functions
Write backend code
Set up complex integrations
Manage multiple tools and platforms

Meerkats AI eliminates all of that.

What Makes Meerkats AI Perfect for Lovable Apps

No Backend Code Required: Meerkats auto-maps your Supabase schema and lets you trigger workflows directly from database changes. Everything happens visually in a spreadsheet-like interface.

Built for Supabase: Since Lovable integrates seamlessly with Supabase, and Meerkats runs natively on Supabase, you get a complete stack without juggling multiple platforms.

Visual Workflow Builder: Define messages, triggers, and conditions in an intuitive spreadsheet view. No learning curve—if you can use a spreadsheet, you can use Meerkats.

MCP Integration: Hook into any app instantly using MCP (Model Context Protocol) servers. Connect to Slack, Google Sheets, OpenAI, Stripe, and more without integration headaches.

Built-in Analytics: See which messages work, where leads drop off, and what to double down on—all inside the same interface.

Step-by-Step: Connecting Lovable Cloud to Meerkats AI

Prerequisites

Before you start, make sure you have:

A Lovable account with an active project
Supabase connected to your Lovable app
A Meerkats AI account (sign up at meerkats.ai)

Step 1: Create the Edge Function in Lovable

First, you'll need to set up an edge function in Lovable that Meerkats AI can communicate with.

In your Lovable chat paste the below prompt:

Create an edge function named 'meerkats_automation' and disable its jwt_auth

Lovable will:

Generate the edge function code
Deploy it to your Supabase project
Provide you with the function URL

What this does: This creates a webhook endpoint that Meerkats can call to trigger actions in your app. Disabling JWT auth allows Meerkats to communicate securely using its own API key system.

Step 2: Copy Your Meerkats Webhook API Key

Log into your Meerkats AI account
Navigate to your project settings
Copy your Webhook API Key (it will look something like: 237b32f75b18ca582ef87754226a...)

Important: Keep this key secure—it's how Meerkats authenticates with your Lovable app.

Step 3: Add the API Key to Lovable Secrets

In Lovable, click on the Cloud tab
Navigate to Secrets
Click Add New Secret
Name it: MEERKATS_WEBHOOK_API_KEY
Paste your API key from Step 2
Click Save

Why this matters: Storing the API key in Supabase secrets keeps it secure and out of your code. Your edge functions can access it without exposing it to the client side.

Step 4: Update Your Edge Function Code

You'll need to replace the default edge function code with code that handles Meerkats webhooks properly.

In Lovable, navigate to:

Cloud → Edge Functions → meerkats_automation

Replace the code with:

import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
import * as postgres from "https://deno.land/x/postgres@v0.17.0/mod.ts";

// Allowed PostgreSQL column types (whitelist)
const ALLOWED_COLUMN_TYPES = [
  "TEXT",
  "VARCHAR",
  "CHAR",
  "INTEGER",
  "BIGINT",
  "SMALLINT",
  "DECIMAL",
  "NUMERIC",
  "REAL",
  "DOUBLE PRECISION",
  "BOOLEAN",
  "DATE",
  "TIMESTAMP",
  "TIMESTAMPTZ",
  "TIME",
  "TIMETZ",
  "INTERVAL",
  "UUID",
  "JSON",
  "JSONB",
  "ARRAY",
  "BYTEA"
];

serve(async (req) => {
  // Handle CORS
  if (req.method === 'OPTIONS') {
    return new Response(null, {
      headers: {
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Methods': 'POST, OPTIONS',
        'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
      },
    });
  }

  try {
    // Verify API key
    const apiKey = req.headers.get('x-api-key');
    const expectedKey = Deno.env.get('MEERKATS_WEBHOOK_API_KEY');
    
    if (!apiKey || apiKey !== expectedKey) {
      return new Response(
        JSON.stringify({ error: 'Unauthorized' }),
        { status: 401, headers: { 'Content-Type': 'application/json' } }
      );
    }

    // Parse request body
    const body = await req.json();
    const { action, table, data } = body;

    // Initialize database connection
    const databaseUrl = Deno.env.get('SUPABASE_DB_URL')!;
    const pool = new postgres.Pool(databaseUrl, 3, true);
    const connection = await pool.connect();

    try {
      // Handle different actions
      switch (action) {
        case 'insert':
          await handleInsert(connection, table, data);
          break;
        case 'update':
          await handleUpdate(connection, table, data);
          break;
        case 'delete':
          await handleDelete(connection, table, data);
          break;
        default:
          throw new Error(`Unknown action: ${action}`);
      }

      return new Response(
        JSON.stringify({ success: true }),
        { headers: { 'Content-Type': 'application/json' } }
      );
    } finally {
      connection.release();
    }
  } catch (error) {
    console.error('Error:', error);
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    );
  }
});

async function handleInsert(connection, table, data) {
  const columns = Object.keys(data).join(', ');
  const values = Object.values(data);
  const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
  
  const query = `INSERT INTO ${table} (${columns}) VALUES (${placeholders})`;
  await connection.queryObject(query, values);
}

async function handleUpdate(connection, table, data) {
  const { id, ...updates } = data;
  const setClause = Object.keys(updates)
    .map((key, i) => `${key} = $${i + 1}`)
    .join(', ');
  const values = [...Object.values(updates), id];
  
  const query = `UPDATE ${table} SET ${setClause} WHERE id = $${values.length}`;
  await connection.queryObject(query, values);
}

async function handleDelete(connection, table, data) {
  const query = `DELETE FROM ${table} WHERE id = $1`;
  await connection.queryObject(query, [data.id]);
}

Click Save to deploy the updated function.

Step 5: Get Your Edge Function URL

Go back to Edge Functions in Lovable Cloud
Click on meerkats_automation
Copy the function URL (it will look like: https://gsofzexofxehdrywofbd.supabase.co/functions/v1/meerkats_automation)

Step 6: Connect to Meerkats

Log into your Meerkats AI dashboard
Click Connect to Lovable Cloud
Paste your edge function URL
Click Connect

Meerkats will verify the connection and sync with your Supabase database.

What You Can Build with This Integration

Once connected, you can create powerful automations in Meerkats:

User Onboarding Flows

Send welcome emails when users sign up
Trigger onboarding sequences based on user behavior
Award credits or unlock features after specific actions

Conversion Funnels

Track users through your conversion journey
Send targeted messages based on where they drop off
A/B test different messaging strategies

Engagement Campaigns

Re-engage inactive users automatically
Send milestone celebrations (e.g., "You've created 10 projects!")
Notify users about new features they might like

Data Sync and Integration

Sync user data to your CRM
Update external spreadsheets when data changes
Connect to Slack, Discord, or other team tools

Analytics and Tracking

Monitor key metrics in real-time
Build custom dashboards
Export data for analysis

Real-World Example: Automated Welcome Email

Here's how easy it is to set up a welcome email in Meerkats:

Trigger: New row in users table
Condition: email_verified = true
Action: Send email via Resend/SendGrid
Template: "Welcome to [Your App]! Here's how to get started..."

That's it. No code. No complex setup. Just visual configuration in a spreadsheet-like interface.

Troubleshooting Common Issues

"Connection Failed" Error

Solution: Double-check that your edge function URL is correct and the function is deployed
Check: Make sure JWT auth is disabled on the edge function
Verify: Your API key is correctly saved in Supabase secrets

"Unauthorized" Response

Solution: Verify the API key in Lovable Secrets matches your Meerkats API key exactly
Check: There are no extra spaces or hidden characters in the key

Workflows Not Triggering

Solution: Ensure your Supabase tables have the correct triggers set up
Check: Verify the table names in Meerkats match exactly (case-sensitive)
Test: Try manually triggering a test event in Meerkats

Database Permission Errors

Solution: Check that your Supabase policies allow the edge function to access the necessary tables
Fix: You may need to adjust Row Level Security (RLS) policies

Security Best Practices

Never expose your API keys: Always store API keys in Supabase secrets, never in your code or frontend

Use environment variables: For different environments (dev, staging, production), use separate API keys

Monitor your logs: Regularly check edge function logs for unusual activity

Rotate keys periodically: Update your Meerkats API key every few months for added security

Enable RLS: Always use Row Level Security on your Supabase tables to control data access

Pricing Considerations

Lovable: Starts at $20/month for hobby projects Meerkats AI: Free tier available; paid plans start based on workflow volume Supabase: Free tier includes 500MB database and 2GB bandwidth

Total cost to get started: You can build and test this integration entirely on free tiers, making it perfect for side projects and MVPs.

Why This Stack is Perfect for Indie Hackers

The Lovable + Supabase + Meerkats AI stack is ideal for solo founders and small teams:

Speed: Build full-stack apps in hours, not weeks Cost: Start for free, scale as you grow No DevOps: Everything is managed for you Full control: Export your code anytime—no vendor lock-in Community: Active communities on Discord and Twitter for support

Next Steps

Ready to supercharge your Lovable apps with backend automation? Here's what to do:

Sign up for Meerkats AI at meerkats.ai
Follow this guide to connect your Lovable app
Start building workflows in the Meerkats dashboard
Join the community to share what you build

Frequently Asked Questions

Q: Do I need to know how to code? A: No! Both Lovable and Meerkats are built for non-technical founders. If you can describe what you want, you can build it.

Q: Can I use this with existing Lovable projects? A: Absolutely! As long as you're using Supabase, you can connect Meerkats to any Lovable project.

Q: What if I want to customize the edge function? A: The edge function code is fully editable. You can modify it to fit your specific needs, or ask Lovable's AI to make changes for you.

Q: Is my data secure? A: Yes. All data stays in your Supabase database, and Meerkats uses secure webhooks with API key authentication.

Q: Can I disconnect Meerkats later? A: Yes, you can disconnect anytime. Simply delete the edge function or remove the API key from secrets.

Q: Does this work with the Lovable free tier? A: You'll need at least Lovable's paid tier to use Supabase integration and edge functions.

Conclusion

Connecting Lovable Cloud to Meerkats AI gives you the best of both worlds: lightning-fast frontend development with powerful backend automation—all without writing backend code.

This integration represents the future of vibe coding: visual, intuitive, and accessible to everyone, regardless of technical background. Whether you're building your first SaaS, creating internal tools, or launching a side project, this stack lets you focus on your product instead of infrastructure.

Ready to level up your Lovable apps? Connect Meerkats AI today and start building backend workflows in minutes.

Keywords: lovable backend integration, meerkats ai lovable, supabase automation lovable, vibe coding backend, no code backend automation, lovable cloud workflows, supabase edge functions, lovable meerkats integration, no code saas backend, lovable automation platform

About the Author

This guide was created to help vibe coders build more powerful applications without getting stuck on backend complexity. For more tutorials on no-code and AI-powered development, visit [your blog/website].

How to Connect Lovable Cloud to Meerkats AI: Complete Guide for Vibe Coders