OpenAI + Google Sheets: consistent interview scores
Phone screens should be quick. But the follow-up turns into a messy mix of half-written notes, “gut feel” decisions, and someone trying to reconstruct what the candidate actually said.
Recruiters feel it when five calls land back-to-back. Hiring managers feel it when the “why” behind a score is missing. And founders doing their own hiring run straight into the same wall. This interview scoring automation gives you consistent pass/fail decisions, plus clear notes, without rewriting the same evaluation every day.
You’ll connect a transcript source to n8n, let OpenAI evaluate the transcript against your criteria, then log a clean row to Google Sheets so the pipeline stays readable.
How This Automation Works
Here’s the complete workflow you’ll be setting up:
n8n Workflow Template: OpenAI + Google Sheets: consistent interview scores
flowchart LR
subgraph sg0["Evaluate Candidate Flow"]
direction LR
n0["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/webhook.dark.svg' width='40' height='40' /></div><br/>Webhook"]
n1@{ icon: "mdi:swap-vertical", form: "rounded", label: "Edit Fields2", pos: "b", h: 48 }
n2@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model2", pos: "b", h: 48 }
n3@{ icon: "mdi:robot", form: "rounded", label: "Evaluate Candidate", pos: "b", h: 48 }
n4@{ icon: "mdi:robot", form: "rounded", label: "Convert to JSON", pos: "b", h: 48 }
n5@{ icon: "mdi:database", form: "rounded", label: "Save to Google Sheets", pos: "b", h: 48 }
n6@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model1", pos: "b", h: 48 }
n7@{ icon: "mdi:robot", form: "rounded", label: "Structured Output Parser1", pos: "b", h: 48 }
n0 --> n1
n1 --> n3
n4 --> n5
n3 --> n4
n6 -.-> n3
n2 -.-> n4
n7 -.-> n4
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n3,n4,n7 ai
class n2,n6 aiModel
class n5 database
class n0 api
classDef customIcon fill:none,stroke:none
class n0 customIcon
Why This Matters: Inconsistent interview decisions
Most teams don’t struggle to do phone screens. They struggle to process them. Someone has to copy the transcript from a tool, skim it, decide if the candidate qualifies, then paste the summary somewhere the rest of the team will actually look. It’s tedious, so it gets rushed. Then the next person reviews the same candidate and comes to a different conclusion because the criteria weren’t applied the same way. Multiply that by a few roles and a busy week, and your “pipeline” becomes a pile of opinions.
It adds up fast. Here’s where the friction usually shows up.
- Transcript reviews happen in batches, which means good candidates wait days for a clear next step.
- Different reviewers emphasize different signals, so “pass” can mean three different things.
- Manual copy-paste into a spreadsheet leads to missing fields like location, phone, or a usable reason for the decision.
- When someone asks, “Why did we reject them?”, the answer is often buried in chat logs or not written down at all.
What You’ll Build: AI-scored transcripts logged to Sheets
This workflow listens for a phone interview transcript sent to n8n via a webhook (your interview system posts the final transcript when the call ends). n8n pulls the transcript text out of the incoming payload, then hands it to an OpenAI-powered evaluator built around a clear checklist. The AI agent returns structured fields like the candidate’s name, phone, city/state, a qualifies yes/no decision, and the reasoning behind it. Next, a formatting step makes sure the output is reliable and consistent, then the workflow appends a new row to Google Sheets so your team has one place to review and filter candidates. No more “where did that transcript go?” moments.
The workflow starts with a transcript webhook. OpenAI evaluates the transcript against your requirements and produces clean JSON. Finally, Google Sheets becomes the system of record for pass/fail outcomes and notes, ready for follow-up.
What You’re Building
| What Gets Automated | What You’ll Achieve |
|---|---|
|
|
Expected Results
Say you run 10 phone screens a week. Manually, it’s easy to spend about 15 minutes reading a transcript, then another 5 minutes copying details and writing a decision, so roughly 3 hours weekly. With this workflow, the only real human time is a quick skim of the AI’s notes and the occasional criteria tweak, maybe 2 minutes per candidate. That’s close to 2 hours back each week, while your spreadsheet stays uniform.
Before You Start
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- OpenAI API for transcript scoring and extraction.
- Google Sheets to store decisions, notes, and details.
- OpenAI API key (get it from the OpenAI API dashboard)
Skill level: Beginner. You’ll connect accounts, paste in a webhook payload once, and edit evaluation criteria in plain English.
Want someone to build this for you? Talk to an automation expert (free 15-minute consultation).
Step by Step
A transcript hits your webhook. Your phone interview tool sends the final transcript at the end of the call, and n8n receives it instantly through the Inbound Webhook Trigger.
The workflow extracts the actual transcript text. Many tools wrap transcripts inside a deeper JSON structure, so the “Extract Transcript” step pulls the right field and ignores everything else.
OpenAI evaluates the candidate against your criteria. The AI agent reads the transcript and produces structured outputs (name, phone, city/state, qualifies, reasoning) so you get consistency instead of freeform paragraphs.
Results are formatted and logged to Google Sheets. A JSON formatting/parsing layer keeps the output predictable, then “Append to Sheets” adds a new row you can sort, filter, and share.
You can easily modify the evaluation checklist to match a new role, then keep the same logging structure in Google Sheets based on your needs. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the Webhook Trigger
Set up the inbound webhook so external systems can send candidate transcripts to the workflow.
- Add the Inbound Webhook Trigger node and set HTTP Method to
POST. - Set the Path to
351ffe7c-69f2-4657-b593-c848d59205c0. - Connect Inbound Webhook Trigger to Extract Transcript to start the execution flow.
Step 2: Set Up Transcript Extraction
Normalize the incoming payload so downstream AI nodes can reference the transcript reliably.
- Open Extract Transcript and add an assignment with Name set to
body.message.artifact.transcript. - Set the Value to
{{ $json.body.message.artifact.transcript }}. - Connect Extract Transcript to Evaluate Applicant.
Step 3: Set Up AI Evaluation and JSON Formatting
Use the AI agent to score the candidate and then normalize the output into a structured JSON format.
- In Evaluate Applicant, set Text to
=Transcript: {{ $json.body.message.artifact.transcript }}and keep Prompt Type asdefine. - Open OpenAI Chat Engine A and select the model
gpt-4o-mini. Credential Required: Connect your openAiApi credentials. - Verify the AI connection: OpenAI Chat Engine A is linked as the language model for Evaluate Applicant.
- In JSON Formatter, set Text to
={{ $json.output }}and ensure Has Output Parser is enabled. - Open OpenAI Chat Engine B and select the model
gpt-4o-mini. Credential Required: Connect your openAiApi credentials. - Confirm Schema Output Parser is connected as the output parser for JSON Formatter and its schema example matches the desired JSON structure.
Step 4: Configure Google Sheets Output
Append the structured candidate data into your spreadsheet.
- Open Append to Sheets and set Operation to
append. - Set Document to
[YOUR_ID]and Sheet toSheet1(valuegid=0). - Map columns to values: name →
{{ $json.output.name }}, phone →{{ $json.output.phone }}, cityState →{{ $json.output.cityState }}, qualifies →{{ $json.output.qualifies }}, reasoning →{{ $json.output.reasoning }}. - Credential Required: Connect your googleSheetsOAuth2Api credentials.
name, phone, cityState, qualifies, reasoning) or the append may fail.Step 5: Test and Activate Your Workflow
Validate the end-to-end flow from webhook to AI evaluation and Google Sheets logging.
- Click Execute Workflow and send a POST request to the Inbound Webhook Trigger URL with a payload containing
body.message.artifact.transcript. - Confirm that Evaluate Applicant produces a JSON object and JSON Formatter outputs valid JSON.
- Verify a new row is appended in the target Google Sheet by Append to Sheets.
- Once validated, toggle the workflow to Active for production use.
Troubleshooting Tips
- Google Sheets credentials can expire or need specific permissions. If things break, check the Google connection inside n8n’s Credentials tab and confirm the spreadsheet is shared with the connected account.
- If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
- Default prompts in AI nodes are generic. Add your brand voice early or you’ll be editing outputs forever.
Quick Answers
About 30 minutes if your transcript source can send webhooks.
No. You’ll paste in credentials, point the Google Sheets node to your spreadsheet, and adjust the evaluation checklist text.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in OpenAI API costs, which are usually a few cents per transcript depending on length.
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
Yes, and you should. Update the criteria inside the “Evaluate Applicant” AI Agent instructions, then keep the same structured output fields (or add new ones) in the Schema Output Parser. Common tweaks include changing the checklist for a new role, adding a numeric score alongside qualifies, or capturing extra fields like availability, salary expectations, or license type. If you change output fields, also update the “Append to Sheets” column mapping so your sheet stays aligned.
Most of the time it’s an invalid or expired API key, or billing isn’t enabled on the OpenAI account. Update the OpenAI credentials in n8n, then re-run a single test execution. If it fails only on longer transcripts, you may also be hitting model or token limits, which means trimming the transcript or switching models can help.
Quite a lot—most small teams can run it daily without thinking about limits.
Often, yes, because this kind of workflow benefits from structured parsing and a bit of logic around “what counts as qualified.” n8n is strong there, and you can self-host for unlimited executions if volume grows. It also handles richer AI chains (agent + structured output parsing) without feeling bolted on. Zapier and Make are still solid if you want a quick webhook-to-sheet prototype, but you may spend more time fighting formatting issues and task limits. If you want help picking the simplest path, Talk to an automation expert.
Once this is running, every phone screen ends the same way: a clear decision, a written reason, and a row your team can act on. Honestly, that consistency is what makes hiring move faster.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.
