You got a message.

Maybe it was a Discord DM. Maybe it was an email. It said something like "Hey, you're invited to [event]" — and if you're the kind of person who's careful about what you click, your first thought was probably a totally reasonable: "Wait, why me? Is this spam? Who gave them my details?"

Fair. Honestly, fair. The internet has earned your suspicion.

So here's the short, honest answer, written the way we'd explain it to a curious five-year-old.

First: who actually sent it?

Not us. Not some marketing robot. Not a random company that bought your email.

The invite came from a community you're already part of. A server you joined. A calendar you follow. A coach you booked with. A group you said yes to at some point. You're in their address book because you chose to be.

We're just the little helper they use to send invites out without having to DM every single person by hand.

Think of it like this: if your football coach sent a group text for Saturday's match, you wouldn't call it spam. Auto-Invite is the same thing — it's your coach, your clan leader, your yoga teacher, your study group host — reaching out to you. We just carry the message.

Second: why you specifically?

This is the part people are often surprised by, in a nice way.

Your community isn't picking names out of a hat. When they set up the event, our system looks at a few friendly signals and tries to invite the people most likely to actually enjoy it:

• You've come to their events before. Especially similar ones. If you always show up to Saturday tournaments, you're going to be near the top of the list for the next Saturday tournament. Makes sense, right?
• Your schedule probably fits. If you've said you're usually free on weekday evenings, you're less likely to get spammed about a Tuesday 9am thing.
• Your friends are going. If a few people you usually show up alongside are already in, we gently nudge you too — because events are more fun with the people you actually know.

And if you're brand new and have no history yet? You still have a fair shot — we reserve a little space in every wave for new members, so newcomers aren't invisible.

The point is: somebody who knows your community picked the rules, and a careful little system tries to respect them. No firehose, no strangers-on-a-list, no "we scraped you from somewhere."

Third: why it feels calm, not spammy

Here's a promise we take seriously. If you don't reply to one of our invites, here's exactly what happens next:

1. The first invite arrives. Usually a Discord DM if we can reach you there, an email if not.
2. If you don't reply — nothing happens for 24 hours. No pings. No badges. No "hey are you there?". You get a day of silence.
3. One gentle nudge, a day later. Same event, same wording-ish, one friendly reminder in case the first one got buried.
4. If you still don't reply — another full day of silence.
5. One final note, 48 hours after that. Usually by email this time, because if you didn't open Discord twice, you're probably not on Discord this week. This is the "last heads-up" and we mean it.

Then we stop. Forever. For that specific event.

That's three messages, spread across two-and-a-bit days, across at most two channels. No fourth try. No "just circling back!" two weeks later. If you've ignored the first three, we read the room and leave you alone.

And if you reply "no thanks" at any point? We stop immediately. No guilt-trip follow-up. No "are you sure?". We just mark you as not coming and move on.

Fourth: what happens when you say yes

The moment you click the invite and RSVP:

• Your seat is locked in. Even if hundreds of other people are looking at the same event, the second you say yes, that spot is yours.
• Everyone else stops hearing about you. Your name comes off the invite list for that event instantly.
• If the event fills up because you were the one who pushed it over the line — the entire invite campaign shuts down. Everyone else stops getting messages about it. You helped close the door behind you.
• You get the actual event details. Time, link, location, who else is coming, whatever applies. Not from us — from your community's page.

That's it. Clicking yes is the end of the back-and-forth, not the start of a newsletter.

A quick tour through one invite — from your phone's point of view

Imagine it's Monday. You're a member of a community that runs Saturday tournaments.

Monday 2pm — Your phone buzzes. Discord DM: "You're invited to Saturday's tournament — want in?" You're in a meeting. You swipe it away. You forget.

Tuesday 2pm — Another Discord ping from the same event. "Just checking if you'd like to come on Saturday." You're at the dentist. You forget again. (We get it. We really do.)

Wednesday 2pm — An email this time. "Last heads-up for Saturday — would love to have you." You're on the bus home. You open it. You click yes.

Your screen now says "You're in. See you Saturday." You stop getting messages about this event. Your community sees your name on the guest list. Done.

If you'd ignored all three? The messages would have simply stopped on Wednesday. No fourth try. We'd have assumed Saturday just wasn't your week.

Things you can do if you want more control

A few useful things most guests don't realise they can do:

✋ "Not this one, thanks." Click the decline button on any invite. It's a single tap. You're out, instantly, and the system doesn't keep trying.

🔕 "None of these, thanks." If auto-invites aren't your thing at all, there's an opt-out inside your community's page. One click and you won't receive automated invitations from that community again — their manual invites still reach you, which is what most people actually want.

🧭 "Only ones I'd like." Fill out the little availability section on your profile (what days you're free, what kind of events you enjoy). It's optional, it's private, and it dramatically improves which invites you get. The system leans on it heavily.

🗑️ "I'm done with this community entirely." Leave the server or unsubscribe from the calendar. You will never hear from us about that community again. No hoops.

Your attention is yours. We're just trying to use a little bit of it, carefully, when there's something you might genuinely want to know about.

And the things we will never do

Worth saying out loud:

• We don't sell your email. Not ever. Not to anyone. Not a single row.
• We don't invite you to events from communities you aren't part of.
• We don't send you "growth" messages, promos, or upsells disguised as invites.
• We don't keep pinging you after you've said no, or after you've ignored us three times.
• We don't secretly add you to mailing lists, newsletters, or "related communities".

If any of that is ever happening to you and it feels like it's from us, it isn't — and we'd genuinely like to hear about it so we can investigate.

The honest version, in one paragraph

A community you joined wanted to run an event. They asked a helper (that's us) to reach out to the people most likely to enjoy it. The helper sent you a message. If you ignore it, you'll get at most two gentle reminders over two days — one of them by email if the first couple were on Discord — and then the helper goes quiet for good. If you say yes, your seat's locked in and you stop hearing about that event. If you say no, you stop hearing about it immediately. That's the whole system.

One-sentence version

Someone you already know is throwing an event, and a careful little helper sent you a friendly note so you don't miss it — and if you ignore the note, it will stop after three very polite tries.

That's really all there is to it.

Thanks for reading. And if you do show up Saturday — have a great one. The host went to a lot of effort to make sure it happens.

A guide for anyone who's ever stared at a half-empty guest list and sighed

Let's start with a feeling you know.

You're running an event. A tournament, a study group, a coffee meetup, a coaching call. You've picked a date. You've written a nice description. And now comes the part that nobody enjoys: chasing people.

You message a few friends. Some say yes, some say "maybe next time", most say nothing at all. You wait. You check again. You feel weird sending a second message. You feel weirder sending a third. The event is tomorrow and you still have eight empty seats and you're tired.

We built Auto-Invite so you never have to do that again.

And the best way to explain how it works is to pretend you're five.

Imagine you're planning a birthday party

You want 20 friends to come to your party. But you don't know which 20 will actually show up. Some are busy. Some never reply to anything. Some would love to come but nobody asked them.

So what would a really, really thoughtful friend do for you?

They wouldn't spam all 200 people in your contact list at once — that's embarrassing.

They wouldn't message one person per day for a month — you'd never get to 20.

A thoughtful friend would do this:

"Let me text ten people first and see who says yes. If loads of them say yes, I'll chill — we're almost there. If nobody replies, I'll try a few more. If someone hasn't answered by tomorrow, I'll gently nudge them. If they still don't answer the day after, I'll try reaching them a different way — maybe email instead of a DM. And once you hit 20 yeses, I'll stop immediately so you don't end up with 40 people in a tiny room."

That's the whole system. Everything below is just the thoughtful friend, doing their job, every few minutes, for as long as you need.

Meet your thoughtful friend

Here's what they actually do from the moment you flick the switch:

🎯 First, they ask you three tiny things

• How many seats do you want filled? (20? 50? 200?)
• By when? (default: two weeks, you can change it)
• Which channels are okay? (Discord DMs, email, or both)

That's it. No forms. No 15-step wizard. No "advanced settings" tab to panic about.

📬 Then they send the first small wave

Not a blast. A small, careful first wave — about 20% of your target. Ten people if you want fifty, a hundred if you want five hundred.

Why only 20%? Because your thoughtful friend doesn't actually know yet which of your community members are going to be excited about this event. So they test the water with a small group chosen carefully — people who've come to your past events, people whose schedules match, people who show up when certain other people also show up (this matters more than you'd think — people come to events because their friends are coming).

The first wave goes out one invite every five seconds — slow enough to feel human, fast enough that ten invites finish in less than a minute.

🧠 Then they pay attention

This is the part people always light up about when we show them.

After the first wave finishes, your thoughtful friend looks at what happened.

Lots of people said yes quickly? 🔥 That means this event is going to fill up fast. So the next wave gets smaller, and it waits a bit longer. No reason to rush — your event is already on its way to full.

Nobody replied at all? 🥶 That means the message didn't land, or those ten weren't the right ten. So the next wave gets bigger, goes out sooner, and reaches further into your community.

A normal mix? Steady as she goes. Another wave in a couple of minutes.

You don't have to tell the system any of this. It just... notices. And adjusts. And the effect is that your events fill up at a pace that matches how exciting they are, without you ever touching a dial.

📞 And if someone doesn't respond, they try again. Kindly.

Here is the part that most invite tools get wrong. They either give up after one message, or they pester people until everyone hates them.

Your thoughtful friend does exactly three touches, spaced out over two days:

1. The first hello. Sent via Discord DM if we can, email if we can't.
2. The gentle nudge. 24 hours later, if they haven't replied. Same channels.
3. The last knock. 48 hours later, on email this time — because if someone ignored two Discord pings, they're probably not on Discord this week. Email is the polite "last chance" channel.

After that, the system stops. Forever. We never hassle the same person about the same event a fourth time. Not because we're being lazy — because it's the right thing to do, and because your community trusts invitations from you exactly as much as you don't abuse them.

🛑 And they know when to stop

The moment your event hits its target number of seats, everything pauses mid-stride. No more waves. No more nudges. The invite engine just quietly turns itself off and marks your event as "done". You don't have to remember to cancel anything.

Same thing happens if you:

• Pause the campaign (planning something? Just pause it.)
• Cancel the event
• Hit the deadline you set

It stops. That's the whole behaviour. It's boring and reliable on purpose.

Let's follow one real guest

Meet Ada. She's a member of your community. She's been to a couple of your events before but missed the last three.

Monday afternoon — you flip Auto-Invite on. You want 20 guests.

A minute later — Ada's phone buzzes. A Discord DM from your event: "Hey Ada, you're invited to the Saturday tournament." She reads it. She doesn't reply. She's at work.

Tuesday afternoon — Another Discord ping. "Just checking in — still hoping to see you Saturday." She's at the dentist. She forgets.

Wednesday afternoon — An email lands in her inbox. "Last heads-up about Saturday — we'd love to have you." She's on the train home. She clicks. She RSVPs yes.

The system immediately:

• Marks her seat as filled
• Tells your event page she's coming
• Stops sending her anything else
• Checks whether your event is now full and, if it is, stops the whole campaign

Ada doesn't know any of this happened in the background. From her side, she just got a friendly message, ignored it twice because life, and clicked it on the third try. That third try was an email, and it landed because she doesn't check Discord on weekdays. If we hadn't tried email, we'd have lost her.

You didn't do any of it. You were having lunch.

The things that make this actually pleasant

A few details that seem small but make a huge difference when you live with this system day to day:

🙂 It doesn't spam. Three touches. Spread over two days. Different channels. Then silence. Your community's relationship with you stays intact.

🤖 It doesn't invite bots. Discord communities collect bots like lint on a sweater. Our system recognises them and quietly skips them, so your invite counts are always real humans.

📊 You can watch it happen. Your event page shows a little progress bar, a "next wave in 2 min 14 sec" countdown, and the history of every wave ("Wave 2 · 5 invites sent · 60% accepted"). It's genuinely nice to watch — a bit like watching dough rise.

⏸️ You're always in charge. Pause. Resume. Cancel. Trigger the next wave right now if you're impatient. It's your event. The system is just the helper.

🔒 It's private by default. Only members of your community get invited. No random strangers unless you explicitly turn that on. Your community is your community.

✨ It gets smarter over time. The more events you run, the more the system learns about who actually shows up when, and the better its first wave gets. Early events take a few more nudges; later events basically fill themselves.

What this really gives you

Here's the honest version.

Before Auto-Invite, running a community event meant spending an afternoon messaging people, feeling bad about being pushy, and still ending up with a half-empty room.

After Auto-Invite, it means clicking a switch, going to lunch, coming back to see that the room is filling up, and then getting on with the parts of community-building you actually enjoy — the event itself, the people, the conversation.

The invite work doesn't disappear. It just stops being your work.

One-sentence version

You tell the robot how many friends you want, and the robot sends kind little messages to the right people, watches who says yes, nudges the ones who forget, and stops the moment your party is full.

That's really it.

If you run events and you've been quietly dreading the chasing part — we made this for you. Flick it on. Go to lunch. Come back to a full room.

Imagine you're throwing a birthday party.

You want 20 friends to come. You don't want to text everyone at once — that's spammy and weird. You also don't want to text people one by one over a week — you'd never finish. So what do you do?

You do what every good host does. You text a handful of people first. You see who says yes. Then you text a few more. If loads of people said yes, you slow down (you don't need many more!). If nobody replied, you invite a bigger group. If someone ignores you, you gently nudge them a day later. If they still ignore you, you send one last message on a different app.

That's exactly what our auto-invite system does, except it invites hundreds of people to events instead of cake.

Let's walk through how it works — first in crayons, then in code.

Part 1 — The crayon version

There are three loops running inside the system, one inside the other, like Russian dolls:

┌──────────────────────────────────────────────┐│  🎉 The Party (one per event)                 ││  ┌────────────────────────────────────────┐   ││  │  📬 The Batches (5–10 per party)        │   ││  │  ┌──────────────────────────────────┐   │   ││  │  │  🧑 Each guest (1–20 per batch)   │   │   ││  │  └──────────────────────────────────┘   │   ││  └────────────────────────────────────────┘   │└──────────────────────────────────────────────┘

The Party loop decides if we should even be inviting people right now. The Batch loop decides how many to invite next, and when. The Guest loop handles one specific person — which app to message them on, and what to do if they ignore us.

Everything else is detail.

Part 2 — Meet the four characters

Every 60 seconds, a little cron job wakes up and asks four questions:

🎪 The Campaign ("Is the party still happening?")

A single database row per event. It knows:

• how many seats you still need,
• whether it's in running, paused, completed, or cancelled,
• when the next batch is due.

If your event is full, or you've already run it for 14 days, or you cancelled — it stops. No more invites, ever. It's safety-first.

📬 The Batch ("Who's going out in this round?")

Not a spam blast. A small, paced group with a specific purpose.

• Batch 1 is always exactly 20% of your target, with a minimum of 10 people. So if you want 50 guests, batch 1 has 10. If you want 500, batch 1 has 100.
• Within a batch, invites go out one every 5 seconds. Twenty invites take 100 seconds to send. You can literally watch the counter go up.
• After each batch closes, the system peeks at how many people said yes and decides what to do next. This is where the magic happens →

🧠 The Adaptive Brain ("How am I doing?")

After a batch finishes, the engine looks at that batch's acceptance rate:

This is the difference between a robot that spams and a system that feels smart. High response → relax. Silence → try harder.

📞 The Follow-Up ("Did they ignore me? I'll try again.")

Here's where we don't give up on you, but we also don't stalk you. Each person gets at most three touches:

Why does the last follow-up lead with email? Because people who didn't open Discord twice probably aren't on Discord that week. Email is the grown-up, reliable channel for the final "hey, seriously, last chance" nudge.

Important: We only send email if it's necessary. If your Discord DM landed, the email never gets sent. If Discord is the only enabled channel and it failed, email still doesn't go out (because it's disabled). Each stage is one successful delivery — not one-of-each.

Part 3 — Let's follow a real invite

Say you're running a tournament on Saturday and the system is auto-filling it. Let's ride along with one person — we'll call her Ada.

Monday 14:00 — You set guest_target = 20 and click Start.

• A InviteCampaign row flips from draft to running.
• next_batch_at is set to now.
• A minute-tick job picks it up.

Monday 14:00:12 — Batch 1 fires. The engine asks the suggestions pipeline for ranked candidates (scored by attendance history + availability + social overlap — see a previous post about that), picks 10 of them, and opens InviteBatch #1.

Monday 14:00:17 — Ada's turn. The dispatcher does four things in order:

// 1. Is she a Discord bot pretending to be human? Drop her if yes.if (botFilter.isBotCandidate(ada)) return skip();// 2. Make sure she exists on Scrims as a calendar member and as a//    guest with status=INVITED. (This is new — V1 dropped this step//    and our hosts were seeing empty guest lists. Fixed.)await ensureScrimsGuest(campaign, ada, event._id);// 3. Try Discord DM first, email as fallback.const result = await deliverViaChannels(stage=0, { discord, email }, ada);// 4. Write the outcome into `Invites.delivery_log`.await Invites.findOneAndUpdate(...)

Her Discord DM lands. The email branch never runs. followup_stage = 0, next_followup_at = Tuesday 14:00:17.

Monday 14:03 — Batch 1 finishes. 10 invites sent. 4 people already accepted (Ada hasn't responded yet). Acceptance rate: 40%. The adaptive brain says "🔥 slow down". Batch 2 is scheduled for Monday 14:08 with 5 people instead of 10.

Tuesday 14:00 — Tick fires. Ada still hasn't responded. Her invite has next_followup_at <= now, so the engine calls deliverFollowup.

• Stage 1 (Discord again) → delivered.
• Her row now reads followup_stage = 1, follow_up_count = 1, next_followup_at = Wednesday 14:00.

Wednesday 14:00 — Still nothing from Ada. Stage 2 fires — but this time email is the primary. Email delivered.

• followup_stage = DONE. No more follow-ups. We've tried our three touches and we respect the silence.

Wednesday 14:11 — Ada clicks the email. She's in.

• Invites.acknowledgment = "accepted".
• scrims.guests.update flips her status from INVITED to CONFIRMED.
• Campaign's seats_filled++ and seats_accepted++.

If the campaign now hits seats_filled >= guest_target, the next tick will call shouldScheduleNextBatch(), get "target-reached" back, and flip the campaign to completed. Job done.

Ada doesn't know any of this happened. From her side, she just got an invite, ignored it twice, then finally clicked it on Wednesday. The engine quietly did all the choreography in the background.

Part 4 — The clever bits we learned the hard way

1. One campaign per event, settings frozen at creation

Naive version: "put default settings on the calendar; every event reads from there." Problem: change the calendar default, all your past events silently start behaving differently. Fix: when an event is first seen, we snapshot the connection defaults onto a fresh InviteCampaign document. Future changes to the calendar don't retroactively affect in-flight campaigns. One source of truth, per event, forever.

2. Adaptive beats greedy

The first cut of V2 just blasted batches of fixed size every 2 minutes. Hosts complained it felt "spammy". The adaptive bands (slow on high acceptance, fast on silence) made the whole thing feel intentional — and cut total invites sent by ~30% for events that fill quickly.

3. The bot problem

Discord guild syncs used to seed every member — including bots — into Scrims as temp members. Those bots leaked into auto-invite candidate pools and got DMs they couldn't read. We now cross-reference the DmMember.bot flag at three layers (suggestion pipeline, candidate fetch, and dispatcher) and exclude them with a clean is_bot reason the UI can render. Belt, braces, and a third strap.

4. Bootstrap the Scrims guest before sending

V1 did it. V2 initially didn't. Hosts saw invites going out with empty guest lists on Scrims. We now call scrims.guests.create(member_id, event_id, { status: INVITED }) as the first step of dispatch — so even if Discord and email both fail, the host sees the intent on their event page immediately.

5. Log everything; render the log verbatim

Every delivery attempt (success, failure, skip) gets pushed into Invites.delivery_log[] with { stage, channel, status, at, reason }. The UI doesn't infer "we tried Discord first" from timestamps — it just reads it straight out of the log. This made debugging a delight and support tickets faster to resolve.

Part 5 — The rhythm, visualised

Here's what one event's life looks like on the wire:

t=0        ┃ 📤 Batch 1 (10 invites, 5s apart) ──── 50st=3m       ┃ 📤 Batch 2 (5 invites — acceptance was hot)t=8m       ┃ 📤 Batch 3 (adaptive again)t=D1       ┃ 🔁 Follow-ups fire for non-responders from batch 1t=D2       ┃ 📧 Final email nudge for still-silent folkst=filled   ┃ ✅ Campaign → completed. No more work.

And the UI streams this to the organiser live: a progress bar filling up, a countdown ticking down to Next batch in 2 min 14 sec, and a batch history that shows Batch 2 · 5 sent · 60% accepted · 14:08.

One-line takeaway

Auto-invite V2 is three nested loops — campaign, batch, per-person follow-up — each with its own clock, its own fallback channel, and its own stop condition. The outer loop knows when to quit. The middle loop knows how fast to go. The inner loop knows how not to be annoying.

The robot sends a few invites, looks at how people reply, and decides if it should chill, speed up, or nudge once more. Then it repeats until your party is full.

That's it. That's the post.

Engineering notes: the engine lives in consistent-backend/v2/€-09-auto-invite/campaigns/. The pure scheduler math (no I/O) is in scheduler.js — unit-test your way to any future tweaks there. The dispatcher (dispatcher.js) is the only file in V2 that writes to Invites, by design, so the shape stays stable for downstream readers. If you change the follow-up timing or channel order, start at constants.js — everything else reads from there.

https://atomcal.com/help/atomcal-for-f1-sim-racing-leagues/