How Harvard Business School Club of New York Automated Their Startup Advisor Program

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

Pain Point	What It Actually Looked Like
Matching Was Expert Work That Didn't Scale	Every new startup intake required someone on the team to read the application carefully, scope sector, stage, objectives, and gaps, then evaluate hundreds of advisors against that profile. Done well, this took 30 to 60 minutes per startup. Done quickly, the quality dropped.
The Logic Lived in People's Heads	The criteria for a great match (preferences over background, sector and functional weighting, stage fit, objectives mapping, contactability gates, tiebreakers) were known to the team but lived as institutional knowledge. There was no system enforcing the hierarchy, so consistency depended on who was doing the matching that week.
Hundreds of Advisors to Consider Every Time	The advisor pool was deep, which was great for matching quality and brutal for matching speed. Every startup had to be considered against the full pool, with overlapping sector groups, related fields, generalist tags, and stage preferences all factored in. Holding all of this in one person's head was exhausting.
Surges Broke the Process	Around events and cohort intakes, application volume spiked. The team couldn't hire on demand for short term peaks, so matches either backed up or got rushed. Either outcome eroded the experience the program was built to deliver.
Reasoning Wasn't Always Captured	When matches were made manually, the why behind each ranking was often communicated verbally and not always recorded in a way the team could revisit. That made handoffs, reviews, and explanations to advisors harder than they needed to be.
Hard to Extend to Other Operations	The same matching logic (preferences, objectives, weighted criteria, tiebreakers) applied to other parts of how the club runs. But without a reusable engine, every adjacent process had to be solved manually too.

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

What It Handles	How It Works
Automatic Match Generation	The moment a new startup is added to Airtable, the engine runs and produces up to 5 ranked advisor matches without any team involvement.
Manual Trigger on Demand	Anyone on the team can rerun the engine for a specific startup at any time, useful for refreshes, backlogs, or after advisor pool updates.
Preferences Outrank Background	The engine prioritizes what advisors want to advise on (sector and functional preferences) over what they've done in the past, exactly the way the team would. Background is used as a backup, never as an override.
Sector and Theme Enrichment	Beyond structured sector tags, the engine reads the startup's description, problem, solution, and objectives to deterministically infer additional sector signals and resonance themes, catching matches that a simple tag filter would miss.
Functional Mapping by Objective	The startup's stated goals (fundraising, GTM, hiring, product, and so on) are mapped to functional areas, which then drive which advisors rank highest for this specific moment in the startup's journey.
Strict Tiebreakers and Data Quality Gates	When two advisors look equally strong, the engine uses a defined, deterministic order of tiebreakers. Advisors without complete contact information or with explicit exclusions never make the cut.
Full Written Reasoning Per Match	Each of the 5 matches comes with a detailed rationale: why this advisor, how they fit the startup's specific needs, and why they rank above the next candidate. Every decision is auditable.
Native Airtable Integration	All matches are written directly into the club's existing "Advisor Matches" table, with the right linked records and status fields. No new tool to learn, no migration required.

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

What used to take us an hour now happens automatically the moment a startup signs up. Five matches, fully reasoned, ready for us to review. It changed how the whole program runs.

Jim Sherman

External Relations Co-Chair • Harvard Business School Club of New York

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.