Matching two people is the easy part. Every event platform can produce a list of names with a compatibility percentage next to them.
What almost none of them do is get those two people into the same room. The list appears, both people nod at it, and then the mechanism ends and hands the hard part back to the attendees: find each other’s email, negotiate a time, remember to show up, and afterwards remember it happened.
Most matches die in that gap. Here’s what we’ve built to close it.
Every request opens a conversation
A meeting request now opens a two-way thread between exactly the two people involved. Not a group, not a channel, not a wall. One conversation per request.
The first message is the invitation text itself, so the thread starts with context instead of an empty box.
What it’s for is the mundane coordination that decides whether a meeting happens: running fifteen late, I’m at stand 12, let’s do it after the keynote instead. Before, those messages had nowhere to go, so people made decisions blind and one of them ended up waiting at the wrong entrance.
Notifications go out by email and push. The email doesn’t carry the message body, deliberately: you read it in the app, where you can answer. The push notification does carry a preview, because a push you have to open to evaluate is a push you learn to ignore.
Threads exist in both event mode and community mode.
The invitation writes itself, mostly
When you request a meeting, the message isn’t a blank field. It’s pre-filled with the actual reasons the system computed for pairing you two, the same “why” you saw on the recommendation, strung together and ready to edit.
That’s a deliberate choice about what to pre-fill with. It isn’t a polite paragraph generated on top of the reasons, it’s the raw material, so you can use it, cut it, or rewrite it entirely. If there are no reasons to show, which happens when you invite someone from the open roster with no prior match, the field is empty and you write it yourself. We’d rather give you nothing than give you something generic.
Picking a time without connecting a calendar
You should not have to hand over your calendar to a conference app. So the scheduling works without one.
One side offers up to three times. The other side picks one, and only the person who didn’t propose can pick, so every scheduled meeting has confirmation from both. A new proposal cancels the previous one, which means there are never two pending answers floating around at once.
At events, the proposed slots come pre-filled from context: the event’s own hours, minus the content sessions that person said they’d attend, with breaks and the networking slot itself counted as free time. If they haven’t marked an agenda, the suggestion comes from the event hours as a whole.
Once it’s agreed, at an event both sides get the time, a calendar file attached, and a reminder before the meeting.
Worth being explicit about two limits. Your connected calendar is not consulted anywhere in this, availability comes from the event, never from your Google or Outlook. And in community mode the meeting is scheduled and that’s where it stops: no notice, no calendar file, no reminder. You follow it from “My introductions.”
When a time never gets agreed
There’s a floor under all of it. At events, both sides get an introduction email with each other’s contact details, sent once. It arrives when the meeting is accepted if the organizer chose that route, or at the end of the event if the in-app proposal never converged.
The same thing happens to matches that don’t fit. In speed-networking mode, when there are more accepted matches than there are slots in the grid, the overflow isn’t discarded: both people get each other’s details so they can sort it out themselves.
Nobody ends an event with a match and no way to reach them.
Declining, and being able to decline
A networking system nobody can say no to becomes a system people stop opening.
You can decline with no reason at all. If you want to give one there’s a list, and only “not interested” removes that pair permanently. The rest are read as preference and leave the person recommendable another time. There’s also an explicit never recommend this person again, which holds regardless.
A decline blocks re-inviting that person for a cooldown window the organizer sets per event, 24 hours by default, up to thirty days, zero if they want to allow an immediate retry. There’s a cap on simultaneous pending invitations and a rate limit on top.
And underneath all of it, one rule that will not change: there is never an automatic connection. However strong the mutual interest, someone has to ask and someone has to accept.
Open events: the whole room, not just your matches
For events without a fixed networking slot, organizers can now turn on full open mode. Every participant sees every other participant, with the same enriched profile and the current meeting status, and can request a meeting with anyone, match or no match. The rest of the cycle is identical.
Opting out of networking is a personal choice, not a per-event one, and it’s revocable. Someone who has opted out doesn’t appear in the roster at all and can’t be invited from it.
Afterwards: did you actually meet?
After the scheduled time, we ask both of you the plainest possible question: did you meet?
One confirmation is enough. Waiting for both is how you end up with meetings that happened and were never recorded.
When it’s confirmed at an event, it lands in the personal CRM of each side who has an account: we create the contact if it didn’t exist and log a met in person note tied to the event, ready for follow-up, tasks, and a cadence.
That’s the part that makes the whole chain worth building. A conference gives you forty conversations and, three weeks later, four remembered ones. This closes the loop into the place where you actually keep your relationships.
Two honest caveats. The question is a yes/no and nothing else: no rating, no “how did it go,” no comments. And in community mode nobody prompts you at the appointed hour, and the confirmed introduction doesn’t yet reach your CRM.
The through-line
Every step above is the same principle applied again: the system does the work that’s genuinely hard for a person (who should meet whom, and when everyone is free), and refuses to do the work that should stay a person’s decision (whether to meet at all, and what to say).
Running an event and want this behind it? It’s live at blablanote.events. Attending one that already uses it? Get the app before you go, and read how to work a conference on the way.
