Case Overview

The Harvard Business School Club of New York runs one of the most rigorous alumni advisor programs in the country. Every founder in the program is an HBS alumni. Every advisor is too. And the bar on both sides is high. The matching process built to meet that bar was thorough: read the startup carefully, weigh sector preferences, functional alignment, stage fit, and human resonance, then evaluate hundreds of advisors against that profile to surface the right top 5. It worked. It just took 30 to 60 minutes of expert time per startup, and it backed up whenever cohorts or events drove a surge in applications.

We replaced that workflow with an internal AI matching engine that lives inside the club’s existing Airtable database. It runs automatically the moment a new startup is added, applies the exact same decision logic the team developed, and produces up to 5 ranked advisor matches in under 2 minutes, each with a detailed written explanation of why that advisor, in that order, for that startup. The team can also trigger it manually whenever they want. The same level of expert judgment now runs on every new intake, instantly, at a fraction of the operational cost.

Company Background

The Harvard Business School Club of New York (HBSCNY) is one of the largest and most active alumni clubs of Harvard Business School, with a community of HBS graduates across the New York metro area. Among its flagship initiatives is an advisor matching program that connects HBS alumni founders with HBS alumni advisors, pairing founders who are still building with experienced operators, investors, and executives who provide direct guidance through the realities of growing a company. Maintaining the quality of these matches is core to the club’s reputation, and the bar is high on both sides.

The Challenge

Our Strategic Approach

This wasn’t a generic “throw an LLM at it” deployment. The point of the project was to faithfully replicate a decision process the team had refined over years, including the tiebreakers, edge cases, and the strict hierarchy of what wins when criteria conflict. We rebuilt that logic as a deterministic engine and wired it into the club’s existing Airtable workflow.

Phase 1: Encode the Decision Logic

We sat with the HBSCNY team to extract the exact matching logic they were running mentally. Not “what should the AI do,” but “what do you do, in what order, with what tiebreakers, when criteria conflict.” That work was translated into a strict, deterministic specification: a hierarchy that puts advisor preferences above background, a canonical mapping of sector and functional groups, a deterministic enrichment step that pulls additional sector and theme signals from the startup’s free text description, a tier framework, a strict tiebreaker order, contactability requirements, and hard data quality gates that exclude advisors who shouldn’t be surfaced.

The key principle: same input, same output, every time. The engine couldn’t be allowed to drift. Consistency and quality was the whole point.

Phase 2: Build the Screener and the Decision Engine

The advisor pool is large enough that running the full decision logic against every advisor on every startup would be slow and expensive. We split the pipeline into two stages: an upstream screener that quickly narrows hundreds of advisors down to the top candidates per startup based on lightweight signals, and a decision engine that runs the full deterministic logic on those candidates to produce the final top 5. The engine evaluates sector preferences, functional alignment with the startup’s stated objectives, stage fit, advisor background as a backup, and human factor resonance, then applies the tiebreaker hierarchy and writes the result back to Airtable.

Phase 3: Wire It Into the Club’s Existing Workflow

We didn’t ask the team to learn a new tool. The engine lives directly inside their existing Airtable database. It runs automatically the moment a new startup is added to the system, and it can also be triggered manually by anyone on the team, which is useful for refreshes, backlogs, or after advisor pool updates. Output is written into a dedicated “Advisor Matches” table: one record per matched advisor, ranked from most to least relevant, each with a full written explanation of why that advisor was chosen and why over the others.

Phase 4: Make Every Match Auditable

Every match record contains a detailed rationale that quotes the exact advisor and startup fields the decision was based on, including comparative reasoning explaining why this advisor ranks above the next. The team can review any match in seconds and see exactly how the engine arrived at the recommendation, which makes review fast and trust easy to build.

Solution: The HBSCNY Matching Engine

Results After Launch

From 30+ minutes per startup to under 2 minutes. What used to require an experienced team member to sit down, read, scope, and weigh hundreds of advisors against multiple overlapping criteria is now produced in under 2 minutes, with the same logic, applied the same way, every time.

Every new startup matched automatically on submission. The team no longer has to remember to kick off the process or wait until they have a window of time. The moment a startup is added to Airtable, the matches are generated and waiting. Nothing falls through the cracks.

5 ranked matches with full written reasoning per startup. Each match comes with an explanation that quotes the exact advisor and startup fields the decision is based on, plus comparative reasoning explaining why the #1 match ranks above #2, and so on. The team reviews in minutes, not hours.

Consistent quality across every match. Because the logic is deterministic (same input, same output), the 1st match of the month and the 100th are evaluated against the exact same hierarchy and tiebreakers. No drift, no fatigue, no inconsistency based on who’s matching that week.

Scales through cohort and event surges without new hires. The constraint of “how much expert matching work can our team do this week” is gone. Volume spikes around events and intakes no longer back up the pipeline or force a tradeoff between speed and quality.

The team’s time freed up for the work that actually requires human judgment. Instead of doing the matching itself, the team now reviews and refines AI generated matches, runs the program strategically, and spends more time on the relationships with founders and advisors that make the program what it is.

Already expanding into other club operations. Because the engine is built as a reusable decision framework (preferences, objectives, weighted criteria, tiebreakers), the same architecture is now being adapted to additional matching and recommendation use cases across other parts of how the club operates.

Client Perspective

Takeaway

Most “matching” problems aren’t actually matching problems. They’re expert judgment problems, and they don’t scale because the expertise lives in people’s heads, the criteria are weighted in subtle ways, and every decision requires holding a lot of context at once.

The standard answers don’t work. A simple filter built on form fields throws out the nuance. A generic LLM throws out the consistency. Hiring more people works until the next surge, and even then, you’re paying experienced people to do work that should run itself.

The right answer is to take the decision logic the team has already built (every preference, every tiebreaker, every edge case) and turn it into a deterministic engine that runs the same way every time. Not to replace the team’s judgment, but to free it from the mechanical part of applying it.

For HBSCNY, that means a matching process that used to consume hours of expert time per intake now runs in under 2 minutes, on every new startup, with full reasoning the team can audit and refine. The bar didn’t drop. The work just stopped being the bottleneck.

If your team is doing expert work that follows a repeatable logic (matching, qualifying, triaging, recommending) and the work is eating their week, this is what solving that looks like.