To automate HR performance review summaries, build a Make.com scenario that pulls data from every source system, normalizes it into a single structured object, sends it through an AI prompt template, and routes the draft to a manager for approval before any record is updated. The entire sequence runs in minutes per employee.

Performance review cycles drain HR bandwidth not because writing is hard — it’s because data assembly is hard. Pulling manager ratings from one system, peer feedback from another, and self-assessments from a third, then normalizing all of it into a coherent narrative, is exactly the kind of repetitive, structured work that breaks teams and breaks deadlines.

This guide shows you how to eliminate that assembly burden using Make.com as the orchestration layer and AI as the narrative engine. The result is a draft-ready performance summary that lands in a manager’s inbox within minutes of data submission — consistent, structured, and ready for human judgment rather than human assembly.

If you’re new to HR automation broadly, start with 11 transformative AI applications for HR and recruiting before working through the steps below. For the specific question of which automation platform to use, the complete 2026 Make vs. Zapier vs. N8N guide gives full context. Teams that have never mapped their existing processes before automating should read what OpsMap™ is and why discovery prevents automation mistakes first.

What You Need Before You Start

Do not open Make.com until you have completed this checklist. Skipping prerequisites is the primary reason performance summary pilots fail.

• Make.com account: Any paid tier. Free tier operation limits will interrupt batch processing during active review cycles.
• HRIS or performance platform API access: You need either API credentials or a reliable export method for every source system feeding the summary.
• Survey or form tool: For collecting self-assessments and peer feedback inputs in a consistent, parseable format.
• AI API key: Use your organization’s approved vendor. This guide is platform-agnostic at the AI layer — the Make.com HTTP module handles the call regardless of provider.
• Compliance clearance: Confirm with legal or privacy that sending employee performance data to an external AI API is permitted under your data governance policy before building anything.
• Prompt template drafted on paper: Write the AI prompt before touching the scenario builder. Knowing exactly what you’ll send determines how you structure every upstream data step.
• Scope limit for pilot: Start with one review category — goal attainment is easiest because data is quantitative. Add peer and self-assessment inputs in iteration two.
• Time estimate: One focused session (3–4 hours) for a single data source pilot. Two sessions for a multi-source workflow with routing and approval logic.

Step 1: Audit and Map Every Performance Data Source

Before you build anything, know exactly what data exists, where it lives, and what format it arrives in. This is not optional groundwork — it is the build.

List every system that holds a data point relevant to a performance summary. Common sources include:

• HRIS: Employee record, tenure, role, department, compensation band
• Performance management platform: Goal scores, competency ratings, manager assessment fields
• Survey tool: Peer feedback responses, 360 inputs
• Spreadsheet or form: Self-assessment narrative responses

For each source, document: the field name exactly as it appears in the system, the data type (numeric score, free-text, dropdown), whether the field is mandatory or optional for a complete summary, and the system’s export or API method. This becomes your data dictionary — the foundation of every Make.com module you build next.

Data fragmentation is consistently identified as the primary obstacle to effective performance management technology adoption. A data dictionary built before automation is the mitigation. Without it, you are building on sand.

Output of this step: A single-page data dictionary listing every field, its source system, its format, and whether the AI prompt requires it.

For teams inheriting broken or undocumented HR operations, the guide to fixing broken HR operations for small teams covers the triage approach that makes this audit faster.

Step 2: Build the Make.com Data-Collection Scenario

The scenario’s job in this step is purely mechanical: retrieve records, normalize field names, and output one clean JSON object per employee. No AI yet.

Choose your trigger

The scenario can trigger on a schedule (run nightly during review cycle weeks), on a webhook from your performance platform when a manager submits ratings, or manually via a button in a spreadsheet. Schedule-based triggers work well for batch processing entire cohorts. Webhook triggers work better for real-time individual processing.

Add one module per source system

Use Make.com’s native app connectors where available, or HTTP modules for REST API calls. Map each source field to your standardized data dictionary field name. Use Make.com’s built-in text parsing and numeric formatting tools to normalize data types — convert all rating scales to the same range (e.g., 1–5) and strip any HTML or special characters from free-text fields before they reach the AI step.

Aggregate into a single structured object

Use a Set Variable or JSON module to compile all normalized fields into one structured object per employee. This object is what you pass to the AI in step three. A clean structure looks like this:

{
  "employee_name": "...",
  "review_period": "Q4 2025",
  "goal_attainment_score": 4.2,
  "manager_rating_communication": 4,
  "peer_feedback_summary": "...",
  "self_assessment_narrative": "...",
  "missing_fields": []
}

Add a missing-field alert branch

Add a conditional branch immediately after the aggregation step: if missing_fields is not empty, route the record to an alert email to the HR coordinator and stop. Do not pass incomplete records to the AI. This is the single most important guard rail in the workflow — it prevents the AI from fabricating data to fill gaps, which is exactly what it will do if you let it.

Output of this step: A working Make.com scenario that reliably produces one normalized JSON object per employee, with a missing-field branch that stops incomplete records before they reach the AI module.

For teams newer to building in Make.com, how a non-technical HR team started building their own automations with Make and AI shows the learning curve in practice. The plain-English guide to Make scenarios covers module logic for readers coming from other platforms.

Step 3: Engineer the AI Prompt Template

The prompt template, not the AI model, determines whether the output is usable. Invest time here before you connect the API module.

What a production-ready prompt includes

• Role instruction: Tell the AI it is an HR writing assistant generating a draft performance summary for manager review. Not a final document. A draft.
• Output format specification: Specify exactly how many sections you want, what each section is named, and the approximate word count per section. Unstructured prompts produce unstructured outputs.
• Data injection points: Mark every place in the prompt where a field from the JSON object will be inserted. Use clear delimiters — double curly braces work well: {{goal_attainment_score}}.
• Tone and voice guidance: Specify the register (professional, constructive, direct) and any language to avoid (superlatives, vague phrases like “good team player”).
• Explicit instruction to not invent: Include a line that reads: “If a data field is marked as missing or blank, state that this information was not available for this review period. Do not infer or estimate.”
• Length cap: Specify a maximum word count. Without one, outputs vary dramatically in length across employees, which creates inconsistency problems at scale.

Test the prompt before connecting it to Make.com

Paste the prompt with sample data directly into the AI interface and review the output. Do this for at least five representative employee records — including one with a high performer, one with a low performer, one with missing fields, and one with very long free-text inputs. Fix prompt issues at this stage. Fixing them after the Make.com connection is live takes three times as long.

Output of this step: A tested prompt template with data injection points mapped to every field in your JSON object, validated against representative sample records.

For teams using Claude as the AI layer, how to write a brief for Claude that produces a production-ready Make scenario covers the structural approach that translates directly to prompt engineering.

Step 4: Connect the AI Module in Make.com

With a clean data object and a tested prompt template, the AI connection step is mechanical.

Add an HTTP module after the aggregation step

In Make.com, add an HTTP module immediately after the JSON aggregation step that produced your structured employee data object. Configure it to call your AI provider’s API endpoint using the POST method. Set the Content-Type header to application/json.

Inject data fields into the prompt

In the request body, build your prompt string by referencing the JSON fields from the previous module using Make.com’s dynamic variable mapping. Every {{field_name}} placeholder in your template maps to the corresponding field from the structured data object. Test the variable mapping on a single record before enabling batch processing.

Parse the AI response

Add a JSON parse or text extract module after the HTTP call to pull the AI-generated summary text out of the API response body. Store it as a named variable — draft_summary — for use in the next routing step.

Add a response-quality check

Add a filter that checks whether draft_summary is empty or below a minimum character threshold. If the AI returned an error or an unusably short response, route the record to the HR coordinator alert queue rather than continuing. Silent AI failures that pass empty strings to managers are a credibility problem.

Output of this step: A Make.com scenario that reliably produces a populated draft_summary variable for each complete employee record, with error routing for failed AI calls.

For teams wanting to understand the full range of what AI-assisted Make builds can handle, AI-assisted Make builds vs. manual builds gives a direct comparison of where AI adds speed and where human review remains essential.

Step 5: Build the Manager Review and Approval Routing

Human approval is not optional in this workflow. It is a required step. An AI draft that writes directly to an employee record without manager review creates compliance exposure and destroys employee trust in the process.

Route drafts to managers, not to records

After the AI module produces draft_summary, add a routing step that sends the draft to the responsible manager via email or your internal messaging system. The message should include: the employee name, the review period, the draft summary, a clear label that this is an AI-generated draft for review, and an edit link or reply mechanism.

Build an edit and approval loop

Provide managers with a form or inline edit interface where they can modify the draft and confirm approval. When the manager submits the approved version, Make.com captures the final text and routes it to the next step. Use a webhook or form submission to trigger this step — do not use a time delay as a proxy for approval. Actual approval confirmation is required.

Handle non-responses

Add a wait module with a defined timeout (48–72 hours is standard for review cycles). If no manager response is received within the window, send a reminder. After a second timeout, escalate to the HR coordinator queue. Do not auto-approve drafts on timeout.

Output of this step: A routing layer that guarantees every AI-generated draft passes through manager review before any downstream action is taken.

Step 6: Write Approved Summaries to the System of Record

Only after manager approval does data touch a system of record. This step is intentionally last.

Write to the performance platform

Use Make.com’s native connector or an HTTP module to write the manager-approved summary text to the appropriate field in your performance management platform or HRIS. Use the employee ID from the original data object as the record identifier — never use name-based matching, which breaks on name changes and duplicates.

Trigger confirmation notifications

After a successful write, trigger a confirmation email to the manager (write confirmed) and a separate notification to HR that the record is complete. Log the completion in a tracking spreadsheet or database table — one row per employee, with timestamps for data collection, AI generation, manager approval, and record write. This log is your audit trail.

Handle write failures

Add error handling on the write module. If the API call fails, route the approved summary text and the employee ID to an HR coordinator alert for manual write. Do not silently drop approved summaries. A failed write that no one knows about is worse than a failed write that triggers an alert.

Output of this step: Approved summaries written to the system of record with a complete audit trail and error-routed failure handling.

For teams building out error handling across their entire Make.com stack, how to set up routed error handling in Make with AI assistance covers the pattern in full.

How to Know It Worked

The workflow is functioning correctly when all of the following are true:

• Completion rate: Greater than 95% of employee records in the review cohort complete the full pipeline (data collection → AI draft → manager approval → record write) within the review cycle window.
• Manager edit rate: Track what percentage of AI drafts managers edit before approving. A rate above 40% signals prompt quality problems. A rate below 5% signals managers aren’t actually reading drafts — which is also a problem.
• Time to draft: From manager rating submission to draft in inbox should be under 10 minutes for individual records, under 60 minutes for batch runs of 50+ employees.
• HR coordinator intervention rate: The percentage of records that route to the coordinator alert queue (missing fields, AI failures, write errors) should drop each cycle as data quality improves upstream.
• Audit trail completeness: Every completed record in the tracking log has a timestamp in all four columns: data collection, AI generation, manager approval, record write. No blanks.

Common Mistakes That Break This Workflow

Connecting AI before normalizing data

The most expensive mistake. Inconsistent field names, mixed rating scales, and raw HTML in text fields produce unpredictable AI outputs that no amount of prompt engineering fixes. Normalize first. Always.

Using name-based record matching

Employee name matching breaks on legal name changes, hyphenated names, and duplicate names. Use employee ID as the record key at every step. Build the habit now — it prevents data corruption at scale.

Skipping the missing-field branch

Without it, the AI fills gaps with plausible-sounding fabrications. In a performance review context, a fabricated competency rating that reaches an employee record is a legal and trust problem. The branch takes 10 minutes to build. Build it.

Treating AI draft generation as the final step

The AI is an assembly tool, not a decision-maker. Every workflow that skips manager review and writes directly to employee records creates compliance exposure. The human approval step is the control that makes the entire automation defensible.

Building the full multi-source workflow in session one

Start with one data source. Get one complete end-to-end run working with real data. Add the second source in iteration two. Teams that try to connect four source systems simultaneously during the first build session spend most of their time debugging which system caused which error.

No audit trail

The tracking log is not optional. In a disputed performance review, the question “who approved this and when” must have a documented answer. If the answer is “the automation” with no human record, you have a governance problem.

For a broader list of where AI-built Make scenarios go wrong, 7 things an AI-built Make scenario gets wrong covers the patterns that recur across HR and operations builds. Teams evaluating whether to build this internally or bring in outside help will find DIY automation vs. hiring a Make partner in 2026 a useful decision framework.

Additional Reading

• 11 Transformative AI Applications for HR and Recruiting
• Make vs Zapier vs N8N in the Age of AI: Complete 2026 Guide
• What Is OpsMap? The Discovery Step That Prevents Automation Mistakes
• How a Non-Technical HR Team Started Building Their Own Automations With Make and AI
• 7 Things an AI-Built Make Scenario Gets Wrong (And How to Catch Them)
• How to Set Up Routed Error Handling in Make With AI Assistance
• AI-Assisted Make Builds vs. Manual Builds (2026)
• DIY Automation vs. Hiring a Make Partner in 2026
• What Is Automation-First? Why You Should Automate Before You Add AI
• How to Write a Brief for Claude That Produces a Production-Ready Make Scenario
• How to Evaluate a Make Scenario Built by AI Before It Goes to Production
• Drowning in Admin: How Solo and Small HR Teams Can Fix Broken HR Operations
• 6 Ways the Make MCP Changes Automation Work for HR Teams
• HR Transformation: Practical AI and Automation for Strategic Operations
• How Sarah Compressed a 45-Minute Onboarding Process to Under 4 Minutes