Stripe Webhooks vs a Nightly Reconcile: Subscriptions That Look Paid and Aren’t

Dana Ellis

Dana Ellis

September 21, 2026

Stripe Webhooks vs a Nightly Reconcile: Subscriptions That Look Paid and Aren't

Stripe’s customer portal and your app’s “Pro” badge can disagree for days before anyone notices. The badge went true when a webhook arrived—or when a checkout redirect looked successful—and never went false when a renewal failed, a dispute opened, or a webhook simply never reached you. Solo SaaS operators love webhooks because they feel real-time. They hate reconciles because they feel like accounting. You need both, or you will keep granting access to subscriptions that look paid and are not.

This is not a lecture about event-driven architecture. It is about the specific ways a one-person billing path drifts, and which tool catches which lie.

What webhooks are good at

Webhooks are how Stripe tells you something changed now: invoice.paid, customer.subscription.updated, charge.dispute.created. When your endpoint is up, verifies signatures, and handles idempotency keys, you can unlock a feature within seconds of a successful charge. That latency matters for onboarding. Nobody wants to wait until tomorrow’s cron to use the thing they just bought.

Webhooks also carry the narrative Stripe believes at that moment. Status transitions, period ends, cancellation timestamps—if you model your entitlements from those events carefully, your app can stay close to the ledger without polling every minute.

They shine when the happy path is the common path: card works, invoice pays, subscription stays active. Most of your week looks like that. Building only for the happy path is how founders end up with a billing system that “usually works” and a support inbox that explains the rest.

The catch is delivery. Endpoints go down during deploys. You rotate a secret and forget to update the endpoint. A serverless cold start times out. Stripe retries, then eventually stops. Your database keeps the last successful story. The customer keeps access. Your metrics look fine because “failed renewals” only appear if you asked for them.

Tangled ethernet cables unplugged from a small desk switch

What a nightly reconcile is good at

A nightly reconcile is a boring job that asks Stripe for the ground truth and compares it to your entitlements table. For every active customer in your app, fetch the subscription (or a list of recent invoices) and ask: does our access match their status? If Stripe says past_due or canceled and you still show Pro, fix it and log why.

Reconcile is bad at “instant unlock after checkout.” It is excellent at “we missed three webhooks last Tuesday.” It also catches logic bugs webhooks will never reveal: you handled invoice.paid but never handled the subscription moving to unpaid; you mapped plan IDs wrong after a price migration; you granted lifetime access from a one-time payment and never revisited it.

For a solo operator, nightly is enough for most products. Hourly is nicer if churn and failed cards are common. Real-time reconcile on every login is a pattern some teams use as a belt; it costs API calls and still should not replace webhooks for the happy path. Think of login-time checks as a third rail for suspicious accounts, not as your only billing brain.

Reconcile also forces you to define entitlements as data you can compare. If “Pro” is a tangle of feature flags set from five different handlers, the job will be painful—and that pain is diagnostic. Clean the model until a status string from Stripe can map to a clear access row.

Printed spreadsheet pages spread on a wooden table

The failure mode: paid-looking access

Typical sequence:

  • Customer subscribes. Checkout succeeds. Webhook grants Pro. Everyone is happy.
  • Card fails on renewal. Stripe marks the subscription past due. Webhook to your app fails or is mis-handled.
  • Your app still shows Pro for days or weeks.
  • You notice when a support email arrives, or when Stripe’s dashboard and your admin panel disagree during a random check.

Another sequence: you process checkout success in the browser redirect and treat the webhook as optional. Redirects can be bookmarked, replayed, or abandoned mid-way. Webhooks without reconcile leave you exposed to missed events; redirects without webhooks leave you exposed to clients lying about success. Neither is a ledger.

Disputes and refunds are a third path. The customer still “looks paid” in your crude is_pro boolean while Stripe has already moved money backward. If you only listen for invoice.paid, you will never hear the rest of the story.

A fourth path bites people who use trials: trial ends, conversion fails, and your trial-ending handler never ran. The UI still says Pro because you set it on trial start and only planned to clear it on invoice.paid. Reconcile notices the subscription is canceled. Webhooks alone only help if you subscribed to the right events and your endpoint was healthy that hour.

A practical split that works for one person

Use webhooks for immediacy. Verify signatures. Persist Stripe’s event id and ignore duplicates. Keep handlers boring: translate an event into a small entitlement update, then return 200 quickly. Push heavy work to a queue if you must, but do not pretend the webhook is optional.

Use a nightly reconcile as the auditor. It should:

  • Page through customers who have a Stripe customer id.
  • Compare subscription status and price id to your entitlements.
  • Downgrade or flag mismatches automatically when safe; alert you when not.
  • Record a run log so you know the job actually ran.

Alert on reconcile mismatches the same way you alert on uptime. A silent reconcile that finds drift and only writes a log line you never read is theater. Send the mismatch summary to the same channel that wakes you for downtime.

Also reconcile the other direction occasionally: Stripe subscriptions that have no matching user. Those are abandoned checkouts, deleted accounts, or bugs—and they confuse future you during audits and tax exports.

Keep a manual “refresh from Stripe” action in admin for support days. Reconcile is the fleet sweep; the button is for the one customer on the phone while you watch the dashboard.

When webhooks alone are almost enough

If you have a handful of customers, you stare at the Stripe dashboard daily, and downtime on your webhook URL is rare, you might survive on webhooks plus manual checks for a while. “Almost enough” still fails the week you take vacation or ship a breaking endpoint change. Add the reconcile before the customer count makes manual comparison impossible—not after.

If your product is a tiny tip jar with no recurring entitlements, you may not need any of this complexity. The moment access depends on a subscription status, you are in reconcile territory—even at ten customers.

When reconcile becomes the main safety net

If your webhook path is flaky—shared hosting, frequent deploys, a Zapier middle layer, or event handling scattered across three services—treat reconcile as primary and webhooks as acceleration. Some solo founders temporarily disable complex webhook logic and rely on reconcile plus a “refresh billing status” button for support. That is ugly and honest. Ugly and honest beats a green webhook log that never ran.

Automation middle layers deserve special suspicion. Retries that create duplicate side effects, spreadsheet “databases” that race, and handlers that are not idempotent turn webhooks into a chaos amplifier. If your webhook consumer is a Zap, assume you need reconcile even more—and assume you will see duplicate grants until the Zap is replaced with something that stores an event id as a lock.

What to store so reconcile can work

At minimum, store the Stripe customer id, the subscription id, the price or product id you believe they own, and the entitlement status your app enforces. Optional but useful: the last event id processed, the last reconcile timestamp, and a short reason string when you auto-downgrade someone. Without those fields, reconcile becomes a vague “something is wrong” alert instead of a fix.

Avoid encoding plan logic only in webhook handler branches. When price ids change, you want one mapping table to update—not seven switch statements. Future you will thank present you the first time Stripe’s dashboard and your code disagree about which price is “Pro annual.”

Decision rule

Ask two questions after every billing change:

  1. How does the customer get access within a minute of paying?
  2. How do we revoke or correct access within a day of Stripe changing its mind?

Webhooks answer (1). Nightly reconcile answers (2). If you only built (1), you will keep a set of subscriptions that look paid and are not—until Stripe’s dashboard and your product finally argue in public.

Ship the webhook. Schedule the reconcile. Treat mismatches as production incidents, not as curiosities in a log file. Sleep better than the founder who trusted a single delivery path for money.

One last operational note: put the reconcile on a heartbeat monitor. If the job stops running, you should hear about it before customers do. A reconcile that never executes is indistinguishable from having no reconcile at all—except it gives you false confidence in a checkbox you ticked months ago. Pair that heartbeat with a simple weekly glance at Stripe’s failed-payment and webhook-delivery views. The dashboard will not replace your job, but it will catch the weeks when your endpoint secretly returned 500s and you were busy shipping features.

Money systems fail quietly. Design for the quiet failure, not just the successful checkout screenshot.

More articles for you