Project

Scaling TUM.ai's Recruiting to 1,000+ Applications

How I rebuilt TUM.ai's screening and interview platform, what its latest cycle looked like, and the Postgres design that keeps it fast, fair and private.

6 min read12.11.2026
Dark purple illustration with the TUM.ai logo in the corner: a wide field of lilac dots, one per application, flows through a large outlined TUM.ai "A" and leaves it as a small, orderly grid of twelve glowing dots.

TUM.ai recruits new members once per semester, and a cycle can bring in more than a thousand applications. Every one of them is read by members who volunteer their time for it, next to their own studies.

This autumn, about 1,000 applications came in, and every one of them was screened between Monday and Friday of a single week. The work was spread evenly across the week and across reviewers instead of piling up at the end. Self-service interview booking then ran without a single double booking.

I built the platform that made that possible. This post covers what changed since the first version, what the cycle looked like from the inside, and the engineering underneath: booking as one database transaction, privacy enforced by Postgres itself, and the tests that keep it that way.

Version one, and what the retrospective changed

The first version came together in April 2026: a Next.js app on Supabase that imports the application form's CSV export, matches every application to two reviewers, and gives them a structured scorecard. It ran the summer semester 2026 cycle, and afterwards we met with the people who had used it for a feedback session.

That meeting decided most of what came next. Two points stood out:

  • The review flow should slow the first read down. Screeners wanted a review page built for a considered first read of an application, not a quick first impression.
  • Interviews happened entirely outside the tool. Version one stopped at the invitation. Who interviews whom and when, getting candidates into a slot, the interviewers' notes and their verdict all lived somewhere else. We wanted all of it inside the tool.

Since the end of the first cycle, that feedback has turned into features: a pre-screening stage, screening in teams, an interview desk, self-service interview booking and a much stricter privacy model.

The result: one week, evenly spread

About 1,000 applications, all screened from Monday to Friday. The previous cycle, the first one on the tool, took about the same time. The real jump came before that: in the cycle without the tool, work piled up towards the end and single people had to push the rest through. Since the tool exists, the load is spread evenly across reviewers, and a cycle runs at a steady pace instead of ending in a crunch.

Most of that comes from small things rather than one big feature. Assignments are balanced from the start, so nobody ends up with a stack nobody else touched. New assignments and reminders arrive as direct messages, so nobody has to remember to check the tool. The review page is keyboard-first, and drafts autosave, so a reload lands where you were. A volunteer with an hour to spare spends it on reading, not on clicking.

Interviews were the other half. Last cycle they were planned entirely outside the tool. This time invited candidates booked their own slot from a link, against shared interviewers and rooms, and not a single slot was double-booked.

Fair by leaving things out

Fairness mostly comes down to anchoring: the first number or impression you see pulls your own judgement towards it. You cannot train that away, so the tool keeps the anchor off the screen. Screening is blind by default, and nobody sees another reviewer's result before their own is on record. Interviewers make their call privately and only see their partner's once both have committed.

Where the raw numbers still drift, because one careful screener gives a 3 where another gives a 4, an optional calibration step corrects for strict and lenient screeners. It is always previewed first and never overwrites the original score. The nice side effect: a reviewer who sees less also has fewer things to weigh, so the fair version turned out to be the faster one too.

Interview booking as one database transaction

Booking was where the interesting engineering sat. A slot is only bookable when two people are free for the personal round, two for the technical round, four different people overall, and a room. Many candidates booking at the same time against those shared resources is a textbook race condition: two requests can both see the same interviewer as free and both succeed.

So the application does not try to be clever about it. Booking is a single Postgres function, and every function that changes the schedule takes the same transaction-scoped advisory lock first. Booking, rescheduling and staffing changes therefore run one after another, and each one sees a consistent picture of who is free. Inside that transaction the database picks the panel with the fewest booked interview minutes, which spreads the load across interviewers, and claims a free room.

Below the lock sits a last line of defence: each interviewer's occupied time is stored as a time range, and an exclusion constraint refuses any two overlapping ranges for the same person, across cycles too. Even a bug in the booking logic could not put someone in two interviews at once; the insert would simply fail. Swapping an interviewer or booking by hand goes through the same rules, and CI rehearses the full booking flow end to end before anything reaches production.

Privacy lives in the database, not the UI

Hiding a column in a table component is a convenience, not a guarantee. So the rules that matter are enforced by Postgres itself, with row-level security deciding the rows and column privileges deciding the fields.

  • Sensitive fields stay on the server. Column privileges belong to database roles, so no signed-in session can select sensitive personal fields or review results, not even an admin's. The server reads them with a privileged key only after an explicit admin check.
  • Sign-in only for TUM.ai members. The database itself refuses an account from outside TUM.ai at the moment it would be created.
  • Hidden by default. A new column is invisible to every client role until someone grants it on purpose, so a new field cannot leak just because nobody thought about it.
  • An audit log nobody can edit. Changes land in a log that nobody can alter or delete, and personal details are redacted from what it stores.

pgTAP suites check these rules role by role: what each kind of session can and cannot select, insert or change. If a migration loosens a rule by accident, CI fails before it ships.

The stack and the safety net

The stack is unremarkable on purpose: Next.js 16 and React 19 on Vercel, Supabase for Postgres, auth and storage, Sentry for errors and Upstash for rate limits.

CI runs lint, typecheck, tests with coverage floors, a build, pgTAP with a check that the generated types match the migrations, and a migration safety checker. Playwright then signs in through real Supabase Auth sessions and walks a full screening cycle on a dedicated local stack, from import to decision, plus a complete rehearsal of interview booking.

Production migrations are never applied by hand. The deploy workflow applies them after CI passes on main, then checks that the migration history matches and runs a health check. Much of the code was written with AI coding agents, which is exactly why this deterministic part matters: it does not care who wrote the change.

What the cycle showed

The whole platform ran in production for the winter semester 2026/27 cycle: pre-screening, screening in teams, calibration, the interview desk and self-service booking.

The lesson I take from it: the wins were mostly boring ones. An even load beats a heroic last-minute push, a lock and a constraint beat clever application code, and the fairest information is often the one a reviewer never sees, which is also the fastest. The code lives in a private TUM.ai repository, so there is no link this time. More about my role as Head of Software Development at TUM.ai is on its own page.