Finding, as a present-tense property of the pool

Finding an accountability partner is a pool-shape question, not a checklist

The articles that currently rank for this topic treat "finding" as a sequence of reader-side actions. Make a shortlist. Evaluate qualities. Run a kickoff call. Negotiate a cadence. That framing assumes the reader can see candidates, pick one, and decide. On this site the reader cannot see anyone. The reader is a row in a set, and the verb "finding" describes what the set is doing to itself. Today, that set is 52 rows, drawn from 47 cities across 19 timezones, and 23 non-overlapping viable pairs are already extractable from it.

M
Matthew Diakonov
9 min read
4.9from direct meditator feedback
Every number below was read live from waitlist_entries on 2026-04-23
No operational practice instruction; peer-pairing logistics only
Dana-tradition: free to the reader, scheduler cost borne by the operator

What the other guides leave out

Run the same query and you get a predictable set of pages. They are almost uniformly procedural advice addressed to a single reader. Step one, decide a goal. Step two, list qualities. Step three, scan your contacts. Step four, have a kickoff. Step five, hold a weekly check-in.

That advice is not wrong. It is also not an implementation. None of it tells you what the pool you could actually be drawn from looks like, because those articles are not written against a pool. They are written against a hypothetical reader who will assemble one on their own. This page is written against a real pool, and the honest answer to "how do I find a partner" on this site is here is the current shape; you either fit it or you do not.

The pool, as of 2026-04-23

Six cards. Every number is a direct query on the production database. Every number could be grepped in the repo on the date this page was published.

52 active rows

status in ('pending', 'ready') and morning_utc IS NOT NULL. Everything else is ineligible by definition. Source: waitlist_entries, queried 2026-04-23.

47 distinct cities

The city field is free-text. Duplicates happen when two spellings hit the same place. Still, the first-order number 47 puts the median city at roughly 1.1 people.

19 declared timezones

Mixed IANA identifiers and manual GMT strings because the waitlist form accepts both. The matcher normalizes everything to UTC minutes before comparing.

49 of 52 old students

is_old_student = 'Yes' means the row completed a 10-day residential course in the S.N. Goenka tradition before signing up. The sort reward for both-old pairings makes this the pool's dominant demographic.

80 slot candidates

52 rows produce 52 morning slots plus 28 evening slots from twice-a-day sitters, for 80 slots total. The matcher operates on slots, not on people directly.

23 viable pairs

Non-overlapping, prior-match filtered, scored and greedily picked. If the operator ran every pair at once with no constraints, the ceiling is 23 simultaneous partnerships from one tick of this pool.

What the query actually returned

The number 52 is not narrative. It is the result of a SELECT against waitlist_entries with two predicates. Running the script on the day this page went live produced the figures below.

scripts/best-pending-pairs.mjs

What the pool feeds, what it produces

Five kinds of row feed the pool; the pool is the hub; three things come out, plus the shape change that conditions the next tick. The reader's row is one arrow on the left and, if the cron picks it, contributes to the matches row on the right. The reader never directly touches the hub.

inputs → pool shape → outputs

Fresh signups
Ready-status rows
Retry-eligible
Twice-a-day rows
Timezone / UTC fields
the pool (shape)
23 viable pairs
Matches row
Shared Meet URL
Activity log entry

Top non-overlapping pairs, today

Running scripts/best-pending-pairs.mjs on 2026-04-23 produced 23 non-overlapping viable pairs. The first ten are shown below, unedited. Every line is a pair the cron could promote to a match row at the next tick, provided neither row changes state first.

node scripts/best-pending-pairs.mjs

The cities currently in the pool

A sample of 33 of the 47 distinct cities present in waitlist_entries on the day this page was published. The spread is what it is; readers from cities not represented here still fit the pool if their UTC minute falls within 60 of someone already in it.

Chicago

America/Chicago

Minneapolis

America/Chicago

Berkeley

America/Los_Angeles

Missoula

America/Denver

New York

America/New_York

Tampa

America/New_York

Bangalore

Asia/Calcutta

New Delhi

GMT+5:30

Ahmedabad

GMT+5:30

Mumbai

GMT+5:30

Dehradun

GMT+5:30

Vadodara

GMT+5:30

London

Europe/London / GMT+0

Prague

Europe/Prague

Amsterdam

GMT+1

Berlin

GMT+10 (declared)

Lisbon

GMT+1

Pau

GMT+1

Utrecht

GMT+1

Warsaw

GMT+2

Zurich

GMT+2

Bologna

GMT+2

Copenhagen

GMT+1

Dakar

GMT+0

Montreal

GMT-4

Toronto

GMT-4

Columbus

GMT-4

Houston

GMT-5

Phoenix

GMT-7

San Diego

GMT-7

Scottsdale

GMT-7

Livermore

GMT-7

São Paulo

GMT-3

How a row moves through the pool

Four stages. Each stage is a status string in the database. The row is the reader; the verbs happen to it, not by it.

  1. Submitted

    Row created in waitlist_entries with status 'pending' and contact_count 0.

  2. Cooling

    24-hour holding period since creation. The cron skips rows younger than a day.

  3. 3

    Eligible

    The row enters the eligible pool. Every tick it is a candidate for pairing against other rows with overlapping slots.

  4. 4

    Paired

    The cron writes a match row and promotes the waitlist status to 'matched' (or 'contacted', then 'engaged').

Eight things the cron does to the pool

At every :00 and :30 the pool is inspected and operated on. The operations are ordered; each one depends on the previous one being finished, and together they define what "being found" means inside the runtime.

1

Pool is loaded

A single Postgres query over waitlist_entries returns every pending-or-ready row with populated UTC times. Nothing outside that status set is considered.

2

Slots are built, one or two per row

Each row contributes one morning slot; rows whose frequency is 'Twice a day' and whose evening_utc resolves contribute a second slot, independently.

3

Unordered pairs are enumerated

Every combination of two slots is considered. With 80 slots the matcher examines 3,160 raw pairs in memory before filtering.

4

60-minute hard filter

timeDiff(slotA.utcMinutes, slotB.utcMinutes) above 60 is dropped. Circular distance uses Math.min(|a-b|, 1440-|a-b|) so 23:30 UTC overlaps 00:10 UTC.

5

Prior-pair guard

getPriorMatchedIds returns any pair that has ever been written to matches. Those pairs are silently removed so no two people are paired twice by the scheduler.

6

Lexicographic sort

Four keys, strictly in order: readyScore (2 / 1 / 0), bothOld (true / false), sessionMatch (true / false), smallest UTC diff. No weights. No learned coefficients.

7

Greedy pick

Walk the sorted list. Write a pair if neither slot has been used this tick. Mark both slots used. A twice-a-day row can be in two match rows per tick, one per slot.

8

Pool changes shape

Matched rows leave status pending; fresh rows age into eligibility; retry rows re-enter. The next tick reads a pool of a different shape 30 minutes later.

The pool in four integers

If the whole argument collapses to numbers, these are the ones that survive today. They describe the shape the word "finding" denotes on this site, as of 2026-04-23.

0active rows in status pending or ready
0distinct city strings across the pool
0declared timezones, IANA or manual GMT
0non-overlapping viable pairs right now

None of these numbers are aspirational. All four are the direct output of two queries against waitlist_entries, evaluated on the date in the headline.

Every parameter of the pool, as chips

Every token below can be verified against the repo or the database. None of them is a slogan.

rows: 52 active (pending + ready)cities: 47 distinct stringstimezones: 19 declared valuesold-student share: 49 / 52slots: 80 (morning + twice-a-day evening)viable pairs: 23 non-overlapping todayhard filter: timeDiff <= 60 UTC minsort: readyScore > bothOld > sessionMatch > diffretry cool-off: 7 days post-expirecron: */30 * * * *

Checklist-framed 'finding' vs. pool-framed 'finding'

FeatureCommon guides (checklist-framed)vipassana.cool (pool-framed)
What 'finding' denotesA sequence of reader-side actions: shortlist, evaluate, interview, commit.A present-tense property of the current pool: 'two compatible rows exist'.
Unit of workConversations, vetting calls, background reference checks.One waitlist form, two minutes, zero vetting on the reader's side.
How a match is decidedSubjective judgement about personality, goals, reliability, shared values.Predicate evaluation: is_old_student, session_duration, timeDiff() <= 60, contact_count < 10.
What fails the matchMismatched values, bad chemistry, poor communication.Pool thinness, UTC distance above 60, or a prior match between the two.
Inspection privilegesReader sees profiles and chooses.Reader never sees a candidate before the pair is written. Symmetric, blind to both sides.
Cost modelCoach retainers, paid community memberships, time-intensive search.Free to the reader; the scheduler runs on the operator's Vercel account.
Upper bound on search timeUndefined. Most guides suggest 'keep looking' without a stop condition.Thirty minutes between ticks; 24-hour cool-off for fresh rows.
49 / 52

Forty-nine of the 52 active rows in the pool on 2026-04-23 answered 'Yes' to is_old_student. The sort keys reward both-old pairings, so the dominant demographic of the pool is already someone who has completed a 10-day residential course.

waitlist_entries, live query, 2026-04-23

Why this framing matters for the reader

If "finding" is a reader action, the whole page would be instructions. Ask these questions. Watch for these red flags. Avoid these personality types. That structure presumes the reader has a filterable set to walk through. On this site the reader does not. The reader contributes one row and then the pool either has a compatible shape or it does not, at this tick, at this minute, for this particular UTC-minute value and session duration.

That is also why the service can be free. Paid platforms charge for the reader's right to inspect and choose. The pool framing has no inspection step; the cron is symmetric, there is no client and no service, and the outcome is a row written to a table. There is no good place in that workflow to insert a fee, and that is by design. The service orbits the dana tradition of the 10-day residential courses at dhamma.org, where authorized assistant teachers are not paid and do not charge; a pool-framed matcher inherits that property for free.

Anything operational about the practice itself (how to sit, how to work with a difficulty, how to handle restlessness, what to notice) goes to an authorized assistant teacher, at a 10-day residential course at dhamma.org, and not to this page. This site handles logistics and peer pairing only.

The whole argument, skimmable

  • The query: what does "finding an accountability partner" actually point at.
  • Usual answer: a reader- side checklist of qualities, places, and scripts.
  • This site's answer: a pool property. On 2026-04-23 the pool holds 52 rows across 47 cities and 19 timezones.
  • Pool demographics: 49 of 52 are 10-day course veterans; almost uniform on is_old_student.
  • Pool capacity today: 23 non-overlapping viable pairs are extractable in a single cron tick.
  • Your interface to it: one waitlist form, two minutes; the rest is the scheduler's job.
  • Not for: readers who want to inspect and pick candidates, or who want paid-service guarantees on speed.

Two numbers, spring-animated

The pool currently holds 0 active rows. From those rows, the scheduler could produce 0 non-overlapping partnerships at the next tick, if every greedy pick landed. That ratio is the shape of "finding" on this site, measured on 2026-04-23.

Want a read on what the pool looks like for your timezone?

Book a short call and we will walk through what the current pool shape would do with a row at your UTC minute and session duration.

Frequently asked questions

What does 'finding' mean on this site, specifically?

Finding, as a present-tense participle, describes a state the pool is in, not an action the reader performs. On 2026-04-23 the pool held 52 active rows in status pending or ready, drawn from 47 distinct cities across 19 declared timezones. Whether a particular signup is currently being found is a function of whether another row exists in that pool with a circular UTC-minute distance at or below 60 from one of your session slots. The reader does not inspect candidates. The reader does not interview anyone. The reader is a row in a set, and 'finding' names whatever the set is doing to itself at the next cron tick.

How many viable pairs are actually in the pool right now?

Twenty-three, computed by scripts/best-pending-pairs.mjs on 2026-04-23. That script loads every waitlist_entries row in status pending or ready, enumerates every unordered pair, drops any pair further than 60 UTC-minutes apart, drops any pair that has been matched before, scores the remainder on readiness plus old-student overlap plus identical session duration plus minute-proximity, and greedily picks non-overlapping pairs from the sorted list. Twenty-three is how many the greedy picker assembled without reusing a single row. The top-scoring pair sits twenty UTC-minutes apart at identical one-hour durations; the lowest-scoring of the 23 sits fifteen UTC-minutes apart at 30-minute durations.

What kind of person is already in the pool?

Almost uniformly a graduate of a 10-day residential course. Forty-nine of the 52 active rows answered 'Yes' to is_old_student, which on this site means a person who completed the minimum 10-day course in the S.N. Goenka tradition. That 49 of 52 figure is the most important demographic fact about the pool, because the sort keys reward both-old pairings above both-pending pairings. Three of the 52 rows are not old students, and they are still eligible, but they land further down the sort when a both-old pair is available. In practice, the pool selects for people who have already sat once.

How geographically wide is the pool?

47 distinct city strings and 19 distinct timezone strings for 52 rows. The coverage in April 2026 spans North America (Chicago, Minneapolis, Missoula, Berkeley, New York, Montreal, Toronto, Houston, Phoenix, Scottsdale, Livermore, San Diego, Columbus), Europe (London, Prague, Copenhagen, Amsterdam, Lisbon, Berlin, Zurich, Warsaw, Bologna, Pau, Utrecht, Warrington), Asia (Bangalore, Bengaluru, New Delhi, Ahmedabad, Dehradun, Vadodara, Mumbai), Africa (Dakar), and South America (São Paulo). The geographic breadth is a function of the product being advertised entirely on SERPs; the pool mirrors whoever the search traffic is.

What is the 60-minute UTC window and why 60 rather than some other number?

The filter at src/app/api/auto-match/route.ts line 164 drops a candidate pair if timeDiff(slotA.utcMinutes, slotB.utcMinutes) exceeds 60, where timeDiff is defined two lines earlier as Math.min(|a-b|, 1440-|a-b|), the circular minute distance on a 24-hour clock. Sixty is the operator's calibration for what 'daily partnership' still means. Thirty minutes would starve the pool and produce zero pairs most ticks. Two hours would pair 06:00 sitters with 08:00 sitters and call it a daily partnership, which is not what a daily partnership is. Sixty is the distance at which two adults in different timezones can still reasonably call each other at the same moment.

How often does the pool change shape?

Continuously from signups, every 30 minutes from the cron. The schedule '*/30 * * * *' in vercel.json calls GET /api/auto-match, which loads the pool, enumerates pairs, and writes matches where viable. Each tick can both consume rows (by matching them) and change the eligibility of survivors (by advancing the clock, which shifts 24-hour cool-off gates). A signup submitted at 09:00 is eligible at 09:30 only if more than 24 hours have passed since the row was created, so in practice the first chance for a fresh row to be matched is tomorrow's :00 or :30.

Why does this page treat 'finding' as a pool property rather than an action?

Because the WaitlistEntry schema in src/lib/db.ts does not carry any field the reader could act on. It holds timezone, frequency, session_duration, morning_time, evening_time, is_old_student, status, contact_count, and pass_count. None of that is a quality, an affinity, a lifestyle, or a goal. The matcher cannot see what the general-advice pages spend their words on. The only things the matcher sees are the shapes of the rows in the pool. So the verb 'finding' has to describe a shape-matching operation that the system does to itself, not a quality-evaluating operation the reader does to candidates.

What happens if the pool shape is wrong for me at this moment?

You wait. The row stays in status pending or ready. The next tick is at most 30 minutes away. On any given tick the pool adds new rows (fresh signups aging past the 24-hour cool-off), removes rows (matched into pairs and promoted to matched status), and mutates rows (contact_count increments, retry cool-offs expire). The shape changes around you. The pool at :30 is not the pool at :00, and a signup that was unfindable at :00 may have a partner at :30. The reader's job is to leave the shape alone; every attempt to optimize the shape from the outside invalidates the symmetry the matcher depends on.

How does the matcher avoid pairing the same two people twice?

src/app/api/auto-match/route.ts calls getPriorMatchedIds on one side of every candidate pair and drops the pair if the pair has ever appeared in the matches table in any status other than cold-bilateral-decline. The forward-only guarantee is written once and then enforced on every tick. Its effect on the pool is that the viable subset shrinks monotonically over time for any given member; if you sit in the pool for long enough, you exhaust the partners your particular shape is compatible with, and the only way back into viability is for fresh rows to enter with shapes close to yours.

Does this page teach me how to meditate?

No. Nothing on this page is operational instruction in the Goenka tradition. The 10-day courses at dhamma.org are where technique is transmitted by authorized assistant teachers, and this site only handles the logistics of peer pairing for daily sits after a reader has completed such a course. Any question about how to sit, how to work with a difficulty, how to interpret a bodily state, how to structure a practice, or what to notice belongs in the course and with an authorized assistant teacher, not here.

Related pages on the same topic

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.