All Service Leads.

Roofing contractors often pay lead-gen platforms for stale, shared leads under opaque pricing. The economics break for the buyer, the experience breaks for the homeowner, and nobody owns the relationship.

All Service Leads is built around a simple inversion: one flat price per lead or per call, paid once upfront, with no contract and nothing that renews. A contractor picks a ZIP code and a radius, pays, and gets leads from homeowners who asked about their own roof, or takes the call live when a homeowner is connected.

Single deployment surface (Netlify), single domain (allserviceleads.com), single Postgres (Supabase). Functions handle the API; the rest is static. Every secret lives in Netlify env, every external write is wrapped in a try/catch so a Twilio outage never 500s the lead form.

                          [ Visitor / Contractor ]
                                    │
              ┌─────────────────────┴─────────────────────┐
              │                                           │
       /rr-lp.html                                /dashboard
       (intake form)                              (buyer portal)
              │                                           │
              └─────────────────────┬─────────────────────┘
                                    ▼
                       Netlify Functions  (Express)
   ┌──────────────┬──────────────┬──────────────┬──────────────┐
   ▼              ▼              ▼              ▼              ▼
 leads          orders         stripe         coupons        admin
 /intake        /checkout      /webhook       /validate      CRUD + refund
   │              │              │              │              │
   └──────────────┴──────────────┴──┬───────────┴──────────────┘
                                    ▼
              Supabase Postgres  (transaction pooler · RLS)
              tenant-isolated tables · service vs anon roles
                                    │
             ┌──────────────────────┼──────────────────────┐
             ▼                      ▼                      ▼
       Stripe (live)       Twilio (toll-free)      Resend (verified)
    payments + webhook       SMS lead-blast          transactional

Server-authoritative promo logic

Promo handling lives entirely server-side. The client never sees the rules, the codes, or the discount math — it gets a final price and a yes/no on whether a code applied. Per-user usage caps, max-quantity limits, and per-code constraints are all enforced on the server before any payment intent is created. Codes that aren't meant to be public are kept out of the rendered HTML so view-source can't enumerate them.

Meta Pixel + CAPI deduplication

Browser Pixel + server-side Conversions API (via Stape gateway) both fire Lead when a homeowner completes the intake form. To prevent Meta from double-counting, every browser/server pair shares a deterministic event_id tied to the new lead's record. Meta dedups on collision and the attribution stays clean.

Serverless + Postgres pooling

Short-lived serverless functions cold-starting fresh DB connections on every invocation = pool exhaustion at scale. Solution: route Postgres through a transaction pooler with prepared-statement caching disabled on the client. Skip the latter and you get a stream of duplicate-prepared-statement errors on every cold start.

This is not a portfolio toy — it processes real card payments and sends SMS to real numbers. That changes the engineering bar.

One night earlier this year, admin lead rows stopped being clickable in production. Black-box smoke-test passed (200s everywhere), but interaction logic was missing from the live admin bundle. Worth telling because the response shape is the differentiator.

• Stage branch deploys. All experiments now go through branch deploys with auto-publish off. Easy to burn through a host's deploy quota when every iteration goes straight to prod — branch-deploy isolation makes the iteration cheap and the production pipeline calm.
• Keep the test harness off live communication APIs. Leftover placeholder numbers in seed scripts can fire real failed-delivery events against a real toll-free number, which hurts carrier verification standing. Mock mode + reserved test numbers belong in any seed/CI path.
• Keep the e2e suite in lockstep with the billing model. When the pricing model flipped to upfront-at-create, a handful of older test assertions kept passing while testing the wrong invariant. Easy to miss, worth a sweep.