Your Lovable App Is Live — But How Do You Know When Something Actually Happens?

You shipped your Lovable app. Users are signing up. Maybe payments are coming in.

And you're finding out... by manually checking Supabase. Or refreshing your dashboard. Or waiting until something breaks loudly enough that someone emails you.

That's not how it should work.

This post shows you how to wire up TheNotificationApp so your iPhone buzzes the instant something important happens in your Lovable project — a new signup, a successful payment, a failed job, or anything else you care about. Setup takes about 5 minutes and requires zero infrastructure.

How the integration works

Lovable apps are powered by Supabase on the backend. Supabase gives you Edge Functions — small serverless functions that run server-side and can call any external API.

The pattern is simple:

1. Something happens in your Lovable app (new row in a table, a webhook event, a button click)
2. A Supabase Edge Function triggers
3. The function makes a single HTTP POST to the TheNotificationApp API
4. You get the notification within seconds

No third-party middleware. No Zapier. No Firebase. One endpoint.

Step 1 — Get your TheNotificationApp API key

1. Download TheNotificationApp on your iPhone
2. Sign in with Apple
3. Create a new application (e.g. "My Lovable App")
4. Copy the API key — you'll need it in the next step

The free tier gives you 100 notifications total, which is plenty for testing and early-stage apps.

Step 2 — Add the API key to Supabase

Never hardcode API keys in your Edge Functions. Store them as environment variables instead.

1. Open your Supabase dashboard → go to Project Settings → Edge Functions
2. Add a new secret:
   • Name: NOTIFICATION_APP_KEY
   • Value: your API key from TheNotificationApp

This secret will be available inside all your Edge Functions as Deno.env.get('NOTIFICATION_APP_KEY').

Step 3 — Create a Supabase Edge Function

Open your Lovable project and ask it to create a Supabase Edge Function. You can use this prompt:

"Create a Supabase Edge Function called send-notification that accepts a POST request with a JSON body containing title and body fields, and forwards them to the TheNotificationApp API at https://thenotification.app/api/sendNotification using the NOTIFICATION_APP_KEY environment variable as the app_key header."

Or create it manually. Here's the complete function:

// supabase/functions/send-notification/index.ts

import { serve } from "https://deno.land/std@0.168.0/http/server.ts";

serve(async (req) => {
  const { title, body, link } = await req.json();

  const res = await fetch("https://thenotification.app/api/sendNotification", {
    method: "POST",
    headers: {
      "app_key": Deno.env.get("NOTIFICATION_APP_KEY") ?? "",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ title, body, link }),
  });

  const data = await res.json();
  return new Response(JSON.stringify(data), { status: res.status });
});

Deploy it:

supabase functions deploy send-notification

Step 4 — Trigger the notification from your app

Now you call this Edge Function from anywhere in your Lovable app. Here's a reusable helper you can drop in:

// lib/notify.ts

export async function sendNotification(
  title: string,
  body: string,
  link?: string
) {
  const { data, error } = await supabase.functions.invoke("send-notification", {
    body: { title, body, link },
  });

  if (error) console.error("Notification failed:", error);
  return data;
}

Then use it anywhere:

import { sendNotification } from "@/lib/notify";

// After a new user signs up
await sendNotification(
  "🎉 New signup",
  `${user.email} just created an account`
);

// After a payment goes through
await sendNotification(
  "💰 Payment received",
  `$${amount} from ${customerName}`,
  "https://yourapp.com/admin/payments"
);

// When something breaks
await sendNotification(
  "🚨 Error",
  `Job failed: ${errorMessage}`
);

That's it. Your iPhone will get a notification within seconds of any of these firing.

The use cases that matter most

1. New user signups (most common)

The first time you get a notification that says "🎉 New signup — someone@email.com just created an account" while you're away from your desk is a genuinely good feeling. It tells you your app is working, your funnel is converting, and people are finding you.

Set this up on your users table insert using a Supabase Database Webhook, or trigger it directly in the signup flow:

// In your auth callback or onboarding step
await sendNotification(
  "🎉 New signup",
  `${newUser.email} just joined`
);

2. Payment received

If your Lovable app has Stripe, you want to know the instant money moves. Trigger from your Stripe webhook handler, right after you confirm a payment_intent.succeeded or invoice.paid event:

await sendNotification(
  "💰 Payment received",
  `$${(amount / 100).toFixed(2)} from ${customerEmail}`,
  `https://dashboard.stripe.com/payments/${paymentIntentId}`
);

3. Form submissions or contact requests

If your app has a contact form, a waitlist, or a lead capture — know about it the second it comes in, not when you check your inbox six hours later:

await sendNotification(
  "📬 New message",
  `${senderName}: "${message.substring(0, 80)}..."`
);

4. Backend job failures

Long-running jobs fail silently all the time. Wrap your critical background processes with an error handler that fires a notification when something goes wrong:

try {
  await runBackgroundJob();
} catch (err) {
  await sendNotification(
    "🚨 Job failed",
    `${jobName}: ${err.message}`
  );
}

5. New feedback or feature requests

If you're using a feedback form in your Lovable app, get a push notification for each submission. Reading user feedback the moment it comes in is one of the fastest ways to improve your product:

await sendNotification(
  "💬 New feedback",
  `"${feedbackText.substring(0, 100)}"`,
  `https://yourapp.com/admin/feedback`
);

Other ideas worth setting up

Once you have the helper in place, adding more triggers takes 30 seconds each. Some common ones to consider:

• Subscription cancelled — know before you lose the revenue
• Trial expiring — get a heads-up so you can reach out
• Database approaching row limits — early warning before things break
• New referral or affiliate signup — if you're running a referral program
• Unusual traffic spike — trigger when session count crosses a threshold

Using Supabase Database Webhooks instead of code

If you'd rather not touch your app's code, you can trigger the Edge Function directly from a database event using Supabase's built-in webhook system.

1. Go to Supabase → Database → Webhooks
2. Click Create a new hook
3. Choose your table (e.g. users) and event (INSERT)
4. Set the URL to your deployed Edge Function URL: https://<your-project-ref>.supabase.co/functions/v1/send-notification
5. Add a header: Authorization: Bearer <your-supabase-anon-key>
6. Set the body to pass title and body — or handle the raw payload in your function

This approach means zero changes to your app code. The notification fires at the database level whenever a row is inserted.

Optional: add a link to jump straight to your dashboard

TheNotificationApp supports a link field. When you include it, tapping the notification on your iPhone opens that URL directly. Use it to deep-link into your Supabase dashboard, your admin panel, or the specific record that triggered the alert:

await sendNotification(
  "🎉 New signup",
  `${user.email} just joined`,
  `https://yourapp.com/admin/users/${user.id}`  // opens on tap
);

The full picture

Here's what the complete setup looks like end-to-end:

Lovable app
    └── Supabase backend
          ├── Edge Function: send-notification
          │     └── POST https://thenotification.app/api/sendNotification
          │           └── NOTIFICATION_APP_KEY (env secret)
          └── Database Webhooks (optional, for table-level triggers)

iPhone
    └── TheNotificationApp
          └── receives push via Apple Push Notification service (APNs)

No servers to manage. No Zapier account. No polling loops. A single HTTP call from a function Lovable can write for you.

Get started

• Download TheNotificationApp on iOS →
• View the API docs →
• See all use cases →

The free tier is enough to get started. Once you're hooked — and you will be — Pro is $2.99/month.

Built and hosted in Switzerland. Your notifications are not stored. No tracking, no data selling.