Back to Blog

How to stop expensive work running on unverified signups

Every unverified signup can start work you pay for. How to delay background jobs until verified, cap what's left and see where basic gates break.

Verification email                   $0.001
Workspace setup and database writes  $0.039
Sample data and search indexing      $0.07
AI onboarding summary                $0.24
One signup                           $0.35

22 signups a minute x $0.35          = $7.70 a minute
$7.70 x 60 minutes                   = $462 an hour
$462 x 7 hours                       = $3,234 by morning

It's only an example, but the sums work the same with your numbers. The sum is running right now. It's 4:07 a.m., you went to bed at 11:40 with a quiet dashboard, and at 12:20 a script found your signup form. That was 227 minutes ago. There are 4,994 new accounts (227 x 22), and they've cost you $1,747.90 so far (227 x $7.70). Your phone is face down on the nightstand and nothing has paged you, because nothing has failed. Every function returned a success and every job finished.

If you hit snooze once at 7:11, those nine minutes cost $69.30 (9 x $7.70). When you pick up your phone at 7:20 there are 9,240 accounts (420 x 22), $3,234 is gone, and the script's still running while you look for your laptop.

Hardly any of those accounts has confirmed an email address. They never needed to, because your app did all the work the moment the form was submitted. Closing that gap is what this post is about: delay background jobs until verified, so an account that never opens an inbox costs you a tenth of a cent instead of 35 cents.

Your AI step shares a key with your product. Say your provider allows 200,000 tokens a minute. 22 summaries x 8,000 tokens is 176,000, which leaves 24,000 for everyone else. By 8 a.m. your paying customers usually need about 60,000, so 40% of their requests get through (24,000 ÷ 60,000) and the other 60% come back as errors. The first message lands at 8:04: "Is it down? Our whole team's stuck."

Say you've got $41,000 in the bank and spend $4,100 a month. That's ten months of runway, and last night took about 24 days of it ($3,234 ÷ $4,100 x 30). Six customers ask for their $39 back, another $234. The signup graph you check every morning now has 9,240 people on it who don't exist. By 9 a.m. you have to choose: shut off signups and lose the free plan that brought you nearly every customer you have, or leave them open and keep paying $7.70 a minute to see if it stops by itself.

That night was a scenario. This one happened:

From our early beta

A team whose cloud bill normally ran $200 to $300 a month woke up to a $12,000 bill. Automated registrations had triggered thousands of expensive serverless functions, database operations and background jobs overnight.

That bill is 40 to 60 times a normal month ($12,000 ÷ $300 and $12,000 ÷ $200), and the registrations alone set it off.

Why signups trigger expensive work

Most signup code has one obvious place to hang things: the moment the account row is created. The workspace gets built there, the sample data gets seeded and the AI step runs, so a new person sees a finished product in their first minute. A script gets the same first minute, and submitting your form 22 times costs it almost nothing.

The obvious fix is to turn on email verification. Do it, but then look at what it changes in your code. In a lot of apps it only decides whether someone can sign in. The hook that queued four jobs has already fired by then, so you can have verification switched on and still pay 35 cents for every account that never confirms.

How to delay background jobs until verified

Price everything that runs at signup. Search for every place that reacts to a new account: auth hooks, webhooks, database triggers, onboarding code. Write a cost per run next to each one.

Move the trigger to the confirmation. Before someone confirms, the only things that should happen are an account row and one email. Queue the rest in the same statement that marks the account verified, so a link opened twice queues one batch. This version is for PostgreSQL:

verify_account.sql
with verified as (
  update accounts
  set verified_at = now()
  where id = :account_id
    and verified_at is null
  returning id
)
insert into jobs (account_id, kind)
select id, 'set_up_workspace'
from verified;

Accounts that come in through social sign-in may arrive already verified. Send them through the same function, so there's only one way into the queue.

Give unconfirmed people something to look at. One static sample workspace, shared by everyone, costs next to nothing and keeps some of that first minute. Limit resends too.

Move the costliest step later still. A confirmed email doesn't mean someone's sitting there. Run the AI summary when a person opens onboarding and asks for it. In the scenario, that's $0.24 of the $0.35.

Give free work its own lane and budget. Use a separate queue, a concurrency limit and a separate API key with a hard spending cap, so a bad night can't use up what paying customers need.

Expire what never confirms. Delete unconfirmed accounts after seven days.

Find out in minutes. Alert on signups per minute against the same hour last week. An alert at 12:35 would have turned that night into a 15-minute problem: 15 x $7.70 = $115.50.

[Never confirms]alt[Confirms the email]Submits the formSends one emailOpens the linkQueue workspace setupAsks for first AI resultQueue the AI stepDeletes after 7 daysNo jobs queued yetNew signupYour appJob queueNew signupYour appJob queue
[Never confirms]alt[Confirms the email]Submitsthe formSends oneemailOpens thelinkQueueworkspacesetupAsks forfirst AIresultQueue the AIstepDeletesafter 7daysNo jobs queuedyetNewsignupYour appJobqueueNewsignupYour appJobqueue

Run the same night through the new flow. Say 1 in 10 of those accounts confirms, and a quarter of those ask for the AI step. Both rates are illustrative.

9,240 emails x $0.001          = $9.24
924 confirmed x $0.109         = $100.72
231 AI summaries x $0.24       = $55.44
Total                          = $165.40

That's $3,068.60 less than the $3,234 night, from moving triggers around. The middle bar below is every job moved to confirmation, with the AI step still running there: $331.72 across 9,240 accounts.

Cost per signup, illustrative0510152025303540At signupAt confirmAt first useUS cents
Cost per signup, illustrative010203040At signupAt confirmAt first useUS cents

Where the basic gates break

Say the next wave uses mailboxes that can receive mail, and 7 in 10 accounts confirm instead of 1 in 10. That's 6,468 confirmed x $0.109, plus 1,617 AI summaries x $0.24, plus $9.24 in email, which comes to $1,102.33. Email verification proves someone can open an inbox, and a catch-all domain can give one person as many working addresses as they like.

So you add another gate. Each of these does stop something.

GateStops the jobs forStill pays forTurns awayUpkeep
Email verificationTypos and scripts with no inboxAny mailbox that can receive mailPeople whose email lands in spamWatching bounces
Unique emailsThe same address twiceEvery different addressAlmost nobodyVery little
Disposable-domain blocksKnown throwaway servicesDomains that aren't on your list yetPeople using privacy forwardingA list someone updates forever
Gmail dot and plus rulesOne inbox written several waysA second real mailboxPeople who sort their mail with plus addressesUpkeep as mail services change
CAPTCHASimple scriptsAutomation that gets past itPeople using screen readers or privacy toolsFees and lost signups
Phone requirementCasual second accountsAnyone with another numberPeople without a reliable mobileA charge for every text
Card requirementScripts with no card, casual second accountsAnyone with another cardStudents and people who want to try firstFewer signups
One signup per IP addressRepeats on one connectionAny other networkOffices, campuses and householdsExceptions and tickets
VPN blocksKnown VPN rangesEverything off your listStaff on company VPNsAnother list to maintain
Rate limitsBursts from a few sourcesTraffic spread thinlyReal users on a shared networkTuning per route
Usage capsOne account overrunningEach new account's fresh capAnyone at the cap on a good dayDeciding when to stop
Shorter trialsSome value per accountMore accounts make up the differenceEvery honest userFewer people reach paying
Manual reviewWhat a person can spotAnything that arrives overnightWhoever looks odd to a tired reviewerHours you don't have

Gmail ignores dots in personal addresses, and a plus sign and a word added to an address still reach the same inbox, so a unique-email rule sees different people. Your app just emailed 9,240 addresses, and many of them don't exist. Bounces at that volume can hurt your sender reputation, and then a real person's confirmation lands in spam and their jobs never start. Your gate is now keeping out the customer it was meant to protect. By hand, 30 seconds per account comes to 77 hours for one night.

Stack everything and an honest person gets a code, a puzzle, a text and a card form, while you look after two lists, email rules and limits you picked at 2 a.m. Each of those gates asks about an inbox, a phone or a connection. None of them asks whether this account should get the free thing your jobs are about to pay for.

Deciding who gets the free work

AbuseZero exists to answer that, so you don't have to build your own abuse prevention system. Where your gate saw one confirmed inbox, multi-layer AI risk analysis examines 140,000+ signals, detects linked claims and flags abuse that single checks miss. Your domain list goes stale, and AbuseZero checks mailbox aliases, disposable domains and mail routing for you. Your per-IP rule catches the office next door, while AbuseZero sees beyond an IP address with VPN, hosting, network reputation, Tor and proxy intelligence. A CAPTCHA puts a puzzle in front of everyone. AbuseZero blocks spammy bots, browser automation and malicious scripts while allowing genuine AI agents and assistants. AbuseZero uses a proprietary algorithm, with AI that checks the claim again. Creating a fresh account isn't enough to erase previous activity.

It's one API call and a clear allow or deny, under rules you control. Protect a benefit end to end shows where the call goes, and Observe mode shows what would be denied before anyone is blocked. Your signup flow, queues and spending caps stay yours, and you'll still want every step above. AbuseZero's evaluation covers the moment a free benefit is claimed.

Frequently asked questions

Will waiting for confirmation hurt activation?

It can, because some people won't come back. A static sample workspace and a clear "check your email" screen help.

What if the jobs are running right now?

Pause the free work first and go straight to the first-hour runbook.

Is a confirmed email enough to grant free credits?

It tells you an inbox works and says little else. An AbuseZero evaluation at the moment of the claim returns allow or deny, and the quickstart walks through your first one.

Protect the free work you pay for

Keep reading

Copying your prompt…

Copied the to your clipboard. Give it to your coding agent & it will handle the rest.