Build AI systems that show their work (and learn over time)

AI is powerful — but risky when you don’t know why it made a decision.

Here's how to build a traceable, trainable AI that explains every decision and gets smarter over time. All using simple, no-code tools you already know.

What is traceable AI (and why you need it)

Traceable AI means: Every recommendation, prediction, or action made by your system can be traced back to the input, logic, or data that caused it.

Why this matters:

• You understand what the system is doing
• You reduce errors (and catch them when they happen)
• You learn from the system over time — and improve it
• You protect yourself from legal, ethical, or brand risks
• You can explain decisions to clients or teammates clearly

Without traceability, your AI becomes a black box. And that’s fine… until it’s not.

How to make a traceable AI tool

Let’s build a lead-scoring AI tool as an example. You run a SaaS app that helps people schedule interviews.

You get a lot of signups, but not everyone is a good lead. You want to use AI to score incoming leads based on their job title, company size, and use case.

That means you need to:

• Tag leads as “hot,” “warm,” or “cold”
• Know why the AI gave that score
• Manually review high-impact ones (if needed)
• Track how well it performs over time

Let’s build it step by step.

Step 1: Set up your lead source

Where do your leads come from? In this example, it’s a signup form that sends data to a Google Sheet.

Each row includes:

• Name
• Job title
• Company size
• Use case (short description from the user)
• A unique ID — like an email or internal row ID.

This helps you reliably update the correct row later.

What you need to do:

1. Create a Google Sheet. Columns: Name, Job Title, Company Size, Use Case, AI Score, Reason, Approved?, Feedback,a unique identifier

2. Set up your form (or webhook) to push new leads into this sheet.

That’s your input.

Step 2: Define the AI's logic (the prompt)

Now that your lead data is flowing into a Google Sheet, it’s time to teach the AI how to score it.

You’ll use a simple prompt that tells the AI:

• What to look at (job title, company size, use case)
• How to make a decision (hot/warm/cold)
• Why we want a reason behind every score

Here’s the scoring logic:

• Hot = high intent and perfect fit (likely to convert)
• Warm = maybe a fit, needs follow-up
• Cold = unlikely to convert

For example:

• A “CTO at a 50-person company hiring engineers” → Hot
• A “freelancer exploring tools for personal use” → Cold

Here's the actual prompt you'll use:

You are helping score leads for a SaaS scheduling tool.

Use the lead's job title, company size, and use case to decide if they are a hot, warm, or cold lead.

\- Hot = decision-maker + hiring intent

\- Warm = possible user, but unclear fit

\- Cold = unlikely to convert

Then explain your reasoning in one sentence.

Input:

Job Title: {{job\_title}}

Company Size: {{company\_size}}

Use Case: {{use\_case}}

Respond with:

Score: \[hot/warm/cold\]

Reason: \[your explanation\]

This gives you traceability: not just the score, but why the AI gave it.

Important: Make sure the AI always outputs: “Score: hot” and “Reason: …” exactly like that.

This is important for later steps to work.

Step 3: Connect it all using Make.com (or Zapier)

Let’s connect the pieces.

We’ll use Make.com because it’s visual and beginner-friendly. You can use Zapier if you prefer — the logic is the same.

What to do (in Make):

1. Create a new scenario

• Go to make.com
• Click Create a new scenario
• Click the big + icon to add your first module

2. Add Google Sheets module – “watch rows”

• Search for Google Sheets
• Select “Watch Rows”
• Connect your Google account
• Pick the Google Sheet you set up earlier
• Select the worksheet (tab) that holds your leads
• Choose “From now on” so it only checks for new rows going forward

This will trigger the scenario whenever a new lead is added to the sheet.

3. Add OpenAI module – “create chat completion”

• Click the next +
• Search for OpenAI
• Choose “Create a chat completion”
• Connect your OpenAI account using your API key
• In the Prompt field, paste in the prompt from above

In the “Prompt” field, paste the prompt you wrote in Step 2.

Then replace \[job\_title\], \[company\_size\], and \[use\_case\] with the actual data from your sheet:

• Click into each placeholder
• On the right, click the Google Sheets bubble
• Select the field that matches (e.g. Job Title)
• Do this for all three

This is called “mapping fields” — it just means pulling the data from the sheet into the prompt.

4. Add a text parser (split the AI output)

OpenAI will return both the score and the reason in one block of text.

We need to split it before we write it back to the sheet.

• Click the next +
• Search for Text → Choose “Split Text”
• For “Text to split,” select the output from OpenAI
• For the separator, type: Reason:
• This will give you two parts:
• The first part contains the score line
• The second part contains the reason

5. Add Google sheets module – “update row”

Now we want to update the same row where the lead came in.

• Click the next +
• Search for Google Sheets → Choose “Update a Row”
• Choose the same Sheet and worksheet as before
• For Row Number, click the Google Sheets bubble and select the correct Row ID or index from the “Watch Rows” step.
• In the AI Score field:
• Select the first output from the Text Split (this includes “Score: hot”)
• Optional: Add a small formatter step before this if you want to clean it up (e.g. remove the word “Score:”)
• In the Reason field:
• Select the second output from the Text Split (the actual explanation)

Important: Don’t create a new row — that breaks traceability.

Now you’re writing both the AI’s decision and its reasoning into the same row.

6. Run a test

• Click Run once at the bottom
• Then add a new lead to your Google Sheet
• Make should pick it up, send it to OpenAI, and fill in the score and reason

If it works, click Activate at the top to make it live.

Done. You now have a working prototype of a traceable AI system — ready to test and improve.

Step 4: Add manual review for high-stakes leads

You might not want to trust AI completely — especially for high-impact leads.

Let’s say you want to manually check hot leads before acting on them.

What you’re building

• When a new lead is scored as hot, Make sends you a Slack message
• The message shows the lead info and AI’s reasoning
• There are two buttons: Approve and Reject
• When you click a button, it updates the Approved? column in your Google Sheet

This lets you keep full control over important leads — while letting AI handle the rest.

What to do:

1. After your OpenAI step, add a Filter

You only want this to run for “hot” leads.

• Click the tiny line between modules
• Click Add a filter
• Set the condition like this:
• If AI Score contains the word hot
• (Make sure this is mapped from the AI result)

Only “hot” leads will continue through the next steps.

2. Add a Slack module — “Send a Message”

• Click the + after the filter
• Search for Slack
• Choose “Send a message with buttons”
• Connect your Slack account
• Choose the channel or your username (you can just send it to yourself)

Now fill out the message body like this:

New HOT lead scored by AI

Name: {{Name}}

Company: {{Company Size}}

Job Title: {{Job Title}}

Use Case: {{Use Case}}

AI Reason: {{Reason}}

What do you want to do?

\[ Approve \]   \[ Reject \]

(Use the dynamic fields from your sheet and AI steps)

3. Add two buttons: Approve / Reject

Still inside the Slack message module:

• Scroll down to the Buttons section
• Add two buttons:
  Button 1:
• Text: Approve
• Method: POST
• URL: leave this empty for now — we’ll connect it in the next step

Button 2:

• Text: Reject
• Method: POST
• URL: also leave empty

These buttons will trigger a webhook in Make.com when clicked — but first, we need to create that webhook.

4. Create a Webhook in Make.com (for each button)

Go back to your scenario and:

• Add a new Webhook module at the top-left (use the plus sign)
• Choose: “Custom webhook”
• Click Add, give it a name like “Approve Hot Lead”
• Copy the Webhook URL it gives you

Now go back to your Slack button setup, and for the Approve button:

• Paste that webhook URL into the POST URL field

Do the same process again for Reject — create a second webhook in Make, and paste its URL into the Reject button’s POST URL.

Now when you click a button in Slack, it will trigger the right webhook in your scenario.

5. Add Google sheets — “update row” after each webhook

For each webhook scenario (Approve and Reject), add:

• Google Sheets module → “Update a Row”
• Use the same sheet and worksheet
• Use the Row Number or a unique ID (like email) from the original lead
• For the Approved? column:
• In the “Approve” path: write Yes
• In the “Reject” path: write No

This will update the row in your Sheet to show what you decided.

Now you can step in when it matters, and let the AI run when it doesn’t.

Step 5: Track what happens next (feedback loop)

How do you know if your AI is actually doing a good job?

Simple: you need a feedback loop — a way to see if the AI's prediction matched reality.

Let’s say it tagged a lead as “hot”: Did they actually book a demo? Did they sign up? Or did they ghost you?

If you don’t track what happens, the AI can’t improve. But if you do, you can improve your prompt, fix bad logic, and make the system smarter every week.

What to do (manual version — start here):

In your Google Sheet, use the Feedback column.

After a few days (or once you’ve followed up with a lead), go back and mark:

• Good – Converted
• Wrong – Didn’t convert
• Wrong – AI said cold but they were hot
• Unsure (if nothing happened yet)

Then once a week, read through the feedback.

If you see patterns, update the prompt.

Example fixes:

• If it's scoring freelancers as cold but they keep converting → update the logic to treat freelancers as potential hot leads.
• If too many leads are labeled “hot” but never reply → make the AI more strict.

This is how you teach the system what “good” looks like.

Automate feedback (when you’re ready)

Once you’ve done this manually and it’s working, you can automate parts of it. Here are two ways:

1. Automate it using your CRM:

If you use a CRM like HubSpot, Close, or Pipedrive, you can automate feedback updates using Make.com.

Here’s how the flow works:

How it works:

1. A lead signs up → goes into your Google Sheet
2. AI scores the lead → result is saved in the Sheet
3. Later, the lead becomes a Customer inside your CRM
4. Make.com watches for this change
5. When it sees a match, it updates the Feedback column in your Sheet:

• "Converted" if the CRM shows they became a customer
• "Didn’t convert" if the lead went cold
• "Still open" if they’re in progress

How to set it up (in Make.com):

• Trigger module: Watch for contact updates in your CRM
• Search module: Find the matching email in Google Sheets
• Update module: Update the Feedback column based on status

Now you can compare the AI’s prediction (hot/warm/cold) with the actual result (converted or not).

2: Use app activity (semi-automated)

If you don’t use a CRM, but your SaaS app tracks key events like:

• Booking a demo
• Creating a project
• Upgrading to a paid plan

You can use those actions as conversion signals.

How it works:

1. When a lead does something meaningful (e.g. books a demo), your app sends a webhook or logs that in your backend
2. Use Make.com to listen for those events
3. It finds the matching row in your Google Sheet
4. It updates the Feedback column with something like:

• Converted – Booked demo
• Didn’t convert
• Inactive after 7 days

Now your app behavior confirms or corrects the AI.

Option 3: Use a Google form (Manual, but fast)

If you don’t have a CRM or event tracking yet, but you still want to avoid editing your sheet row by row, here’s an easy fix: create a Google Form.

How it works:

1. Create a simple Google Form with:

• Email address field
• What happened? Dropdown: Converted, Didn’t convert, No response

1. Every time you finish following up with a lead, open the form and submit the result (takes 5 seconds)
2. Use Make.com to:

• Watch responses from that form
• Find the lead in your sheet
• Update the Feedback column automatically

This is still manual, but much faster than editing spreadsheets line by line.