Automate Marketing and Clear $7K/mo with Supabase

A three-person agency in Austin is making a solid $7,000 monthly profit. They automate marketing campaigns for local businesses—not using Zapier or Make, but with a Supabase backend they built over two weekends. Their secret isn't complex AI or proprietary technology. It's about treating marketing automation like a data problem rather than a workflow problem, charging clients $500-$1,200/month for self-running systems.

Photo: Creatopy on Unsplash

Many marketing automation setups collapse under their complexity. Zapier bills can exceed $600/month, Make workflows break silently, and HubSpot's automation builder requires expertise just to navigate. Here's the thing: a Postgres database with edge functions costs only $25/month and handles email sequences, lead scoring, multi-channel attribution, and webhook orchestration without the middleware tax. The gap between what agencies charge and the infrastructure cost is where the $7k margin emerges.

Why Supabase Became the Marketing Automation Backend

Marketing automation platforms like ActiveCampaign, Marketo, and even HubSpot are essentially expensive UIs wrapped around databases. You pay $800-$3,000/month for storing data, implementing conditional logic, and making API calls—all things a Postgres instance does natively. Supabase offers a database, real-time subscriptions, authentication, edge functions, and storage for less than a single HubSpot seat.

Here's the infrastructure breakdown for a typical client campaign managing 12,000 contacts across email, SMS, and retargeting:

Supabase Pro ($25/mo):

• Postgres database with 8GB RAM
• 100GB database storage
• 50GB file storage
• 2 million edge function invocations
• Real-time database subscriptions

SendGrid ($19.95/mo for 50,000 emails):

• Transactional email delivery
• Webhook event tracking
• Domain authentication

Twilio ($0.0079/SMS, ~$80/mo for 10,000 messages):

• SMS delivery with delivery receipts
• Programmable messaging API

Total monthly cost: $124.95

Client billing: $800-$1,200/month per client (depending on volume and channels)

With three clients, that's $2,400-$3,600 in monthly revenue against $375 in infrastructure costs across all clients. Add developer time (15-20 hours/month maintaining all systems after the initial build), and you're looking at $7,000+ monthly profit with just one developer.

Compare this to a Zapier-based approach handling the same volume: 50,000+ tasks/month puts you at the $599/month plan. You're still duct-taping together services that break when APIs change. HubSpot Marketing Hub Professional starts at $800/month per portal—before you've even sent a single email.

The Technical Architecture That Actually Works

Photo: Rodrigo Rodrigues | WOLF Λ R T on Unsplash

The core insight is treating marketing automation as event-driven architecture. Every action—email open, link click, form submission, page view—is an event that triggers database updates and conditional edge functions. No visual workflow builder required.

Database schema is intentionally simple:

-- Contacts table
CREATE TABLE contacts (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  email TEXT UNIQUE NOT NULL,
  phone TEXT,
  lead_score INTEGER DEFAULT 0,
  tags TEXT[],
  custom_fields JSONB,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Events table for all interactions
CREATE TABLE events (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  contact_id UUID REFERENCES contacts(id),
  event_type TEXT NOT NULL,
  event_data JSONB,
  timestamp TIMESTAMPTZ DEFAULT NOW()
);

-- Campaign sequences
CREATE TABLE sequences (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  name TEXT NOT NULL,
  steps JSONB NOT NULL, -- Array of step definitions
  active BOOLEAN DEFAULT true
);

-- Sequence enrollments
CREATE TABLE enrollments (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  contact_id UUID REFERENCES contacts(id),
  sequence_id UUID REFERENCES sequences(id),
  current_step INTEGER DEFAULT 0,
  last_step_at TIMESTAMPTZ,
  status TEXT DEFAULT 'active'
);

Edge functions handle the automation logic. When SendGrid fires a webhook for an email open, an edge function records the event, updates lead score, and checks if the contact should advance in any sequences:

// Edge function: process-email-event
import { createClient } from '@supabase/supabase-js'

Deno.serve(async (req) => {
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  )
  
  const event = await req.json()
  
  // Record event
  await supabase.from('events').insert({
    contact_id: event.contact_id,
    event_type: event.event,
    event_data: event
  })
  
  // Update lead score based on engagement
  if (event.event === 'open') {
    await supabase.rpc('increment_lead_score', {
      contact_uuid: event.contact_id,
      points: 2
    })
  } else if (event.event === 'click') {
    await supabase.rpc('increment_lead_score', {
      contact_uuid: event.contact_id,
      points: 5
    })
  }
  
  // Check for sequence progression
  await supabase.rpc('process_sequence_progression', {
    contact_uuid: event.contact_id
  })
  
  return new Response(JSON.stringify({ success: true }), {
    headers: { 'Content-Type': 'application/json' }
  })
})

Scheduled functions run via cron jobs (Supabase supports pg_cron) to process sequence steps that are time-based rather than event-triggered:

-- Daily cron job to process scheduled sequence steps
SELECT cron.schedule(
  'process-sequences',
  '0 */6 * * *', -- Every 6 hours
  $$
  SELECT process_due_sequence_steps();
  $$
);

The process_due_sequence_steps() function is a Postgres stored procedure that queries enrollments where the next step is due, sends the appropriate message via SendGrid or Twilio, and updates enrollment status.

Three Client Types That Generate Predictable Revenue

Not every business needs marketing automation, but three verticals consistently convert and retain at 90%+ annual rates:

Local Service Businesses (HVAC, Plumbing, Roofing)

Average spend: $600-$800/month

These businesses get 50-200 leads monthly from Google Local Service Ads, Facebook, and referrals. The automation handles:

• Immediate SMS response to new leads (45 seconds vs. 4 hours industry average)
• Email sequence with case studies and reviews for leads who don't convert immediately
• Re-engagement campaigns for past customers at seasonal intervals (furnace checks in October, AC tune-ups in April)
• Review request automation 3 days after job completion

A Dallas HVAC company went from 18% lead-to-booking rate to 31% in 90 days after implementing automated lead response. The owner doesn't touch the system—leads flow from Facebook Lead Ads webhook → Supabase → immediate SMS → booking link.

E-commerce Stores ($50K-$500K Annual Revenue)

Average spend: $800-$1,200/month

Shopify stores in this range can't justify Klaviyo's $350+/month pricing but desperately need abandoned cart recovery, post-purchase sequences, and win-back campaigns. The Supabase approach:

• Shopify webhook integration (order created, cart abandoned, customer created)
• Abandoned cart sequence: 1 hour, 24 hours, 72 hours with dynamic product info
• Post-purchase upsell based on product category
• VIP segment automation when customer lifetime value crosses $500

A boutique fitness equipment store recovered $14,000 in 60 days from abandoned cart emails alone—emails that cost $0.003 each to send via SendGrid. Their previous Klaviyo bill was $120/month for worse deliverability.

B2B Service Providers (Consultants, Agencies, SaaS)

Average spend: $500-$900/month

Lead nurturing is the entire game for B2B, but most founders don't have time to manually follow up or can't afford a full marketing automation platform. The system handles:

• Webinar registration sequences with reminders
• Content upgrade delivery and follow-up
• Lead scoring based on email engagement, website behavior (tracked via Supabase real-time), and LinkedIn profile enrichment
• Sales alert when lead score crosses threshold

A fractional CFO consultancy in Chicago generated 7 qualified calls in Q1 2026 from a 400-person email list—entirely automated sequences triggered by content download. Previous manual follow-up yielded 2 calls per quarter.

The Build Process: Two Weekends to Revenue

The Austin agency's first client system took 28 hours to build. Their third took 6 hours because they'd templatized the core structure.

Weekend One: Infrastructure and Core Tables

• Supabase project setup with environment-specific instances (dev, staging, prod)
• Database schema creation with migrations
• SendGrid and Twilio account setup with domain authentication
• Basic edge functions for webhook processing
• Authentication and row-level security policies

Weekend Two: Client-Specific Logic

• Campaign sequences defined in database (stored as JSON)
• Client-specific edge functions for custom business logic
• Integration with client's CRM or form provider (usually Webhooks or Zapier for one-way sync)
• Admin dashboard using Supabase client libraries + React (they use Retool for speed)
• Testing with real data from client's existing list

Weeks 3-4: Monitoring and Iteration

• Event tracking to confirm delivery rates
• Lead score calibration based on client's actual conversion patterns
• A/B testing email copy and timing
• Client training on viewing reports in dashboard

After the initial build, maintenance is mostly content updates—new email copy, new sequence steps, seasonal campaign adjustments. The infrastructure requires maybe 2 hours monthly per client for monitoring and updates.

Why This Works When SaaS Automation Fails

Traditional marketing automation platforms focus on user count and feature proliferation, not operational efficiency. They charge per contact, per user, per feature—essentially taxing your growth. Supabase flips this: you pay for compute and storage, both of which scale logarithmically with contact volume.

At 50,000 contacts, you're still on the $25/month Pro plan. At 200,000 contacts, you might need the Team plan at $599/month—but by then, you're also billing 20+ clients. The unit economics never degrade.

The second advantage is data ownership and flexibility. When a client wants to integrate their custom-built quoting tool or connect to a weird niche CRM, you write 50 lines of TypeScript in an edge function instead of waiting for Zapier to add an integration or begging HubSpot support for a custom API endpoint. You control the schema, the logic, and the integrations.

Third: real-time capabilities that enterprise platforms charge thousands for come free. A client wanted to trigger an SMS 30 seconds after someone spent more than 90 seconds on a product page without adding to cart. With Supabase real-time subscriptions from their Next.js site and an edge function, this took 45 minutes to implement. In HubSpot, this would require their Operations Hub add-on at $720/month.

The Business Model: Retainers Beat Projects

The critical insight isn't technical—it's commercial. Don't sell "marketing automation setup" as a project. Sell ongoing automation management as a retainer with a 12-month minimum.

Pricing structure that works:

• $2,500-$4,000 setup fee (covers initial build and migration)
• $500-$1,200/month ongoing (covers hosting, maintenance, updates, reporting)
• Optional: $150/hour for custom integrations or major campaign additions

Clients accept this because they're comparing it to $800/month for HubSpot, $350/month for Klaviyo, or $1,200/month for a marketing coordinator who still uses spreadsheets. You're cheaper, faster, and more reliable.

The 12-month minimum is essential. It takes 60-90 days for automation to demonstrate ROI as sequences mature and data accumulates. Clients who bail at month 4 never see the compounding value. Annual contracts with monthly billing work best—clients feel the flexibility of monthly payments but you have revenue certainty.

The Reality No One Mentions

This model works at 3-8 clients. At 10+ clients, you need a second developer or you become a bottleneck. At 20+ clients, you're building an actual agency with hiring, retention, and overhead problems. The beauty of the $7k/month model is that it's a leveraged solo operation or tiny team—but it doesn't scale to $100k/month without fundamentally changing the business.

Also: this isn't passive income. Clients need monthly check-ins, campaign performance reviews, and occasional troubleshooting when their e-commerce platform changes an API. Budget 15-20 hours monthly per client for maintenance and account management. If you hate client communication, this model will destroy you.

What surprised me most? If you're a developer who understands marketing key concepts, can build Postgres schemas in your sleep, and doesn't mind explaining deliverability rates to a plumber—this is the highest-margin consulting model I've seen in 2026 that doesn't require AI hype or VC funding.

Are you treating marketing automation as a SaaS subscription or as infrastructure you can own and profit from?