AI Workflow: Time-in-Stage Analyzer

TLDR: I built a Time-in-Stage Analyzer that turns raw ATS data into actionable bottleneck reports in 25 seconds. It shows you exactly where candidates are stuck, where they're dropping off, and makes recommendations. Built with anonymized data from Greenhouse but adaptable for any ATS that allows CSV exports. Read the steps to recreate this here or reach out here if you'd like help implementing this.

Tools Used: Gumloop, OpenAI GPT-4.1 mini, Google Docs, Google Sheets, Slack.

—————————————————-

Hiring teams face a strange contradiction. They have more hiring data than ever. Stage tracking, conversion rates, time-in-stage averages, pipeline health dashboards. But they still struggle to understand why hiring is slow.

Time-to-hire is one of the most important metrics in recruiting. It's also measured too late to matter. Most teams review it quarterly or annually, which means by the time you notice, you've likely already spent months hiring at a slower pace.

Time-in-stage is different. It's a leading indicator. When you can see how long candidates spend in each stage, you catch problems before they snowball.

Today, most ATSs offer recruitment analytics with fancy pre-built dashboards or customizable widgets that allow you to build reports yourself. The problem is these dashboards show you hand-wavy metrics like “average time-to-hire is 42 days” but don’t help you answer questions like "why did it take us two months to fill that Engineering role?" You don't get to learn where candidates are getting stuck, what stages are causing the delays, why candidates are dropping or what to fix first.

Averages Lie

A 42-day average time-to-hire tells you the overall pace of hiring but it also hides what's actually happening underneath. That same 42-day average could mean:

• Most roles take 35-40 days, but three roles are stuck at 90+ days (you have a specific problem to fix)

• Half your roles take 28 days, half take 56 days (you're running two completely different processes)

• Every role moves smoothly until week 4, then hits a 2-week bottleneck (one stage is broken, not the whole pipeline)

The average is mathematically correct. But it collapses the distribution into a single point and makes different problems look the same.

Even Smart Teams Struggle With This

TA teams want deeper insights but creating any detailed report takes 6-8 hours of focused work. You need to export data, clean it, identify patterns and outliers, create visualizations, write up findings, and share with stakeholders.

This explains why most teams make it a quarterly exercise. Or worse, avoid it entirely as long as their metrics look "fine" compared to industry benchmarks.

And by the time you identify a bottleneck at the end of the quarter, you've already lost weeks of candidates to that same problem. Team morale drops because everyone knows something's broken but can't prove it or fix it.

What the Time-in-Stage Analyzer Does

This workflow turns raw hiring data into a complete bottleneck report in 25 seconds. The analyzer processes data on applications and stage changes, shows you where candidates are stuck, which stages are slowest, where people drop off, and why. It compares roles against each other so you can see if Engineering takes longer than Product, or if certain stages only bottleneck for senior roles.

You also get recommendations specific to what your data shows. A summary is posted to Slack, the full report lives in Google Docs, and all your reports stack up over time so you can track whether your fixes actually worked.

What used to take 8 hours now takes 25 seconds.

What This Makes Possible

TA Ops people didn't get into this field to build pivot tables for 8 hours. When reporting takes minutes instead of hours or days, they can focus on designing better processes, improving candidate experience, partnering with hiring managers, and thinking strategically about hiring.

When you can only analyze quarterly, you fix the most obvious problem and hope for the best. When you can analyze monthly or bi-weekly, you see patterns. You notice when a bottleneck moves from Take Home Task to Hiring Manager Interview. You see that Engineering roles are smooth but Design roles have a new problem.

Data also changes the conversation with leadership. "We need to add headcount to the TA team" is a hard sell. "We identified a 12-day bottleneck costing us thousands per quarter and fixed it in one week" is an easy sell. You go from "trust me" to "here's the data supporting this request."

How it Works

The analyzer is built on Gumloop, uses OpenAI's API for analysis, and outputs to Google Docs and Slack. Here's the workflow:

Step 1: Data Collection

You export two CSV files from your ATS:

1. Applications data: Candidate ID, role, application date, current stage, status

2. Stage transitions: Candidate ID, stage name, entry timestamp, exit timestamp

Most modern ATS platforms (Greenhouse, Lever, Workday, etc.) can export this data natively but the schemas are likely different and may have different names.

Step 2: Data Processing 

• Parses both CSV files

• Joins the tables to match candidates across both datasets

• Calculates time-in-stage for every candidate at every stage

• Groups data by role, stage, and candidate status

Step 3: AI Analysis 

Once the data is processed, it gets sent to OpenAI's API to generate:

• Stage performance metrics: Average, minimum, and maximum time candidates spend in each stage, plus total candidate counts

• Conversion analysis: Percentage of candidates moving from one stage to the next, showing exactly where dropoff happens

• Role-specific analysis: Which jobs have the longest cycle times and which stages are bottlenecks for specific roles

• Dropout analysis: Which stages lose the most candidates and why

• Actionable recommendations: Specific steps to reduce time-in-stage or improve conversion, based on what the data actually shows

  
  The AI identifies patterns a human analyst would spot after hours of manual work, then explains them in clear language.

Step 4: Report Generation

The analyzer creates two outputs:

1. Slack summary: A concise message (under 300 words) posted to your chosen channel with the top 3-5 insights and a link to the full report.

2. Google Doc report: A comprehensive breakdown with:

• Executive summary (key takeaways up front)

• Stage performance metrics (table format showing avg/min/max time per stage)

• Conversion analysis (table showing where candidates drop off between stages)

• Role analysis (table comparing cycle times across different jobs)

• Dropout analysis (which stages lose the most candidates)

• Prioritized recommendations with expected impact

The report gets appended to a master Google Doc, with the newest report at the top. This means you can scroll through months of reports to see trends over time.

Who This is For

This workflow is built for:

• TA Operations Managers tired of spending entire days pulling data when they could be improving processes

• Heads of Talent Acquisition who know something's wrong with their pipeline but can't pinpoint what without drowning in spreadsheets

• People Analytics Teams who want to bring hiring data into their broader people strategy but don't have bandwidth for manual exports and analysis

• TA Teams at Growing Companies hiring across multiple roles and departments and losing visibility into what's actually working
  
  

You Can Start Using This Today

I built this workflow using anonymized data from Greenhouse, but the logic works the same regardless of your ATS. If you use SmartRecruiters, Lever, Workday, Jobvite, or something else, you'll likely need to adjust the field names in the node that joins the tables so they match your CSV columns. This might add an hour or two to setup, but it's a one-time thing. 

For meaningful analysis, I recommend having at least 50-100 candidates in your dataset. The workflow can handle smaller datasets, but the more applications you have, the clearer the patterns become. 

If you'd like help implementing this with data from your ATS, reach out.