All lessons

Base rates — what a piece of evidence is actually worth

A face-recognition system that is 99.9% accurate and almost entirely wrong, and a number that sent an innocent woman to prison. Both are the same arithmetic, and it is the arithmetic that decides what any piece of evidence is worth.

Confirmation and survivorship — what you never looked for

Two questions about evidence you did not go looking for. One is a rule you have to discover, and one is a pattern in five famous people — and in both, the thing that would have told you the truth is the thing nobody checks.

Loss aversion, sunk cost and regression — what it costs you

Four questions you answer about yourself rather than about a scenario, and your own answers are the finding. Then the pattern that makes praise look useless and criticism look like it works, whatever you actually do.

Noise and bias — why a written-down rule beats an expert

One question is still open. You scored a lead in the first lesson, and you are about to score it again — the same lead, the same facts, in a different order. What happens next is the reason machine learning exists.

What a decision tree is — twenty questions

Somebody is thinking of an animal and you get yes-or-no questions. Nobody opens with “is it a dolphin?”, and the reason nobody does is how a decision tree gets built.

Gini impurity — how mixed is this pile?

A tree has to compare two questions and say which is better. To do that it needs a number for how mixed a pile is. Here is that number, built on ten deals you can check on paper.

Entropy — how many questions is the answer worth?

Sixteen animals take four questions, and the first lesson never said where the four came from. It came from entropy, and this lesson proves it by building the best strategy there is and counting.

Information gain — which question to ask first

Twenty-four films, five questions, and two films that answer all five the same way. One was a hit. The question that splits them most evenly turns out to be worth nothing at all.

Tree depth and leaf size — knowing when to stop

One question has been chosen. Now start again on each side. Two things happen that the first split cannot show you.

Overfitting — perfect on what it has seen

A tree can get almost every answer right and still have learned nothing. The test is to keep some data back, build the tree without it, and then ask the tree about it.

Data leakage — the column that gives the game away

Put the employee number back in and the tree uses it. Then add a column that already knows the answer, and watch every safeguard from the last lesson report a success.

Ranking and lift — turning a tree into a list of names

Every lesson so far ended in a number. This one ends in a list of people and a sentence to open with, which is the only form any of it can be used in.

The four steps — named in a line and in a tree

You have built two models four paths apart. A line fitted to 200 markets, and a tree grown on 24 films. They look nothing alike, and the same four questions describe both — except that for the tree, two of them come back empty.

The cost function — squared error is a decision, not a law

One number has been falling for a whole path and nobody has said where it comes from. Squared error was a decision somebody made. Make a different one and the same data gives you a different line.

Greedy search — why the best step is not the best path

The tree searched too. It just never looked back at a question it had already answered. Build every tree it could have built instead, and one of them is better — starting with the question you were taught to reject.

What this path is for

You are about to be handed a working business and asked to take it apart. This is why, and what you will be able to do afterwards.

Your demo org

A real Expedify org, not a sandbox with pretend buttons — what is in it, how you get one, and the three ways people break one in the first week.

The deals board and the seven stages

Seven columns that are not a default. Each one is this business saying what has to be true before an enquiry is allowed to move, and six workflows read them by name.

Inside one enquiry: value, stage, source, next step

One record, six fields, and the empty one that explains half the automations in this org.

Contacts, and the six lifecycle stages

A person and a piece of work are two different things, and they have two different sets of stages. Confusing them is the commonest mistake in a demo.

Products, and where a deal's value comes from

Five products, none of which is attached to a single enquiry. What the catalogue is really for, and where the number on a deal actually comes from.

Notes, tasks and the activity trail

Three kinds of record that look alike and are not, and the one of them that is the only honest measure of whether anybody is actually working a case.

The three parts of a workflow

Every automation in your demo org is the same three things arranged differently. Learn to see them and the whole catalogue stops being nineteen mysteries.

Triggers: the six kinds this org uses

Every workflow has exactly one trigger, and the whole catalogue runs on six kinds. Which one a workflow uses tells you most of what it is for.

Reading a node's configuration

Click a box and you get a form. Learn to read one node's form and you can read every node's form, because they are all the same shape.

Variables: how one node uses another's output

Curly brackets are how one node reads another node's answer. They are the whole mechanism — and the one thing that goes wrong without ever failing.

Conditions and branches

Where a workflow chooses. One arm runs, the other does not, and everything hanging off the arm that did not run simply never happened.

Draft and active: which workflows are actually running

Saving a workflow does not start it. Which raises the question a partner gets asked constantly: of these nineteen, which ones are actually running?

The execution log: run one, then read it

Your org's run history is empty, and that is correct. Create one enquiry, then read everything your org did about it in the next fifteen seconds.

Capturing a lead from any other system

The one workflow in your org that starts outside it. A URL any other system can post to, and the search that stops the same person becoming two contacts.

Filling in what the form did not ask

A lead arrives with four fields filled in. Before anybody calls them, an agent goes and finds what the form did not ask for — and is told exactly what it may not invent.

Scoring a lead against a written rubric

Every enquiry gets a score out of 100 and a band. The scheme is not in the model — it is a document somebody wrote, and changing it changes the scoring.

The first five minutes: call-back and routing

Three workflows react to the same new enquiry within seconds. One scores it, one decides how fast somebody calls, one decides who. None of them knows the others exist.

AI on the phone: qualifying, and writing up the call

One workflow makes the call and asks the questions. A second one writes up whatever was said — and it does that for calls your people made too.

Answering questions on three channels

The same question arrives on WhatsApp, on the website and through a form. Two of the answers come from one agent wearing different clothes; the third has no agent in it at all.

Booking the meeting, and chasing the no-show

One workflow puts the meeting in a diary and moves the deal. Another reminds them, waits out the afternoon, and then goes back to the record to find out whether they actually came.

Two kinds of follow-up: the cadence and the written-for-one message

Everybody goes quiet eventually. One workflow answers that with eighteen nodes of certainty; the other with five nodes and a judgement. Both are right, for different reasons.

Working the old list, and the year after the sale

Two workflows about money already spent: the enquiries that went quiet months ago, and the customer whose loan has just been paid out.

The morning sweep: what has gone quiet

Nobody notices a deal going quiet; they notice a quarter going quiet. One workflow, every morning at half past nine, turns silence into a list of names.

Telling Meta which leads were worth it

The ad platform knows which ads produced a form fill. It does not know which ones produced a customer — unless you tell it. These two workflows tell it.

What a knowledge base is, and how search finds things

Four real questions, four correct answers, and scores ranging from 0.06 to 0.9993 — which is the most useful thing to know about knowledge-base search before you configure one.

Writing a document that comes back

A document on exactly the right subject, sitting in the knowledge base, that the agent could not find. The fix was the writing, and it is measurable.

Giving an agent a knowledge base

The knowledge base is a tool hanging off the agent, pinned to one id by the workflow. What that buys you is a boundary the model cannot argue with.

What is already connected in your org

Eleven things are connected and not one of them is a credential anybody had to go and get. What that means, and what it means about the seven workflows that are drafts.

API keys and OAuth: who has to click

One of these is a string somebody emails you. The other needs a particular person at a particular screen, and it is the one that moves your go-live date.

What each channel needs before it can go live

Four credentials, seven finished workflows waiting on them, and what genuinely has to be true before each one can carry a real customer.

Connecting Expedify as MCP

One config block, and your client's Expedify is available to whatever you already work in — Claude, your editor, your own scripts.

Asking your business a question

Four questions a business asks on a Monday. None of them has a screen in any CRM, and all four are answered in a sentence each.

Changing things by asking

Find it, log it, commit to it, change your mind. Four sentences that would be a dozen clicks — and everything they leave behind.

Building a workflow by asking

Describe it in a sentence and it exists. Then ask the two questions that decide whether it works — and open the canvas, because that is where it lives now.

Building an agent by asking

A rules workflow is wiring you check on a canvas. An agent is a job description you check by reading it — and the words are the whole build.

Building a dashboard by asking

A question on Monday, a dashboard by Monday. It is three objects rather than one, and knowing which is which is what lets you change it later.

The same thing, inside the product

Everything in this module, without a key or a config file — because the client's own team gets the same capability inside the product.

The twelve-minute demo

Twelve minutes, six beats, no slides. Built out of what you have already read, and rehearsed until the third beat works on somebody else's laptop.

What to promise, and what not to

The honest edge of the promise, drawn from things this org actually does wrong — because a partner who knows the limits is the one clients keep.

What learning is — the robot with a bow

A robot that pulls left and high, and cannot see the target. Two of them, identical except that one is told where each arrow landed. That turns out to be the whole difference between a machine that learns and one that does not.

Supervised learning — being told the answer

Somebody stands at the target and tells the robot exactly where the arrow went. That is a label, and this lesson measures the two things about it that cost money: how many you need, and how much each one has to say.

Unsupervised learning — when nobody tells you anything

Take the target away. No coach, no score, no right answer to check against. The robot shoots into an empty field — and something can still be found out from where the arrows land.

Reinforcement learning — only hit or miss

The coach is still at the target and may now say one word. Hit, or miss. Not how far and not which side — and that turns out to be a different problem rather than a smaller one.

Rules against models — not everything is a learning problem

The habit is the same push on every shot. So measure it once, subtract it, and stop. Three lines of arithmetic beat the learner — right up until the wind changes.

Choosing the kind of learning — which is your problem?

Three questions, in a fixed order, sort any problem into the kind of learning its feedback will support. The cost of sorting it wrong is not a matter of opinion, because this path measured every one of them.

Defining AI — what are we actually talking about?

Before anything else: what does the word actually mean? Why the definition keeps moving, the four ways people have tried to pin it down, the one that won because it can be scored, and where machine learning sits inside all of it.

The five approaches to AI — where the knowledge comes from

Five serious ideas about how to build a machine that decides. They are usually taught as a chronology, one retiring the last. That story is tidy and wrong, and the correction is what the second half of this course rests on.

Minimax and game trees — the machine that looked ahead

Every game of tic-tac-toe that could ever happen, counted from the rules. A machine that cannot lose, an idea that skips 97% of the work without approximating anything, and the wall the whole approach hits.

A* and heuristic search — search you can afford

A machine plays chess better than anybody, and it never sees the end of the game. Two ideas separate it from the machine that solved tic-tac-toe, and neither of them is a faster computer.

Expert systems — the machine that reasoned

Fifteen if-then rules that chain into conclusions, work out which questions are worth asking, and can print exactly why they decided. That last part is the one everything after this lesson loses.

The limits of hand-written rules — the arms race you lose

Forty spam rules, each one the best available when it was written. The filter peaks at eighteen and gets worse from there — with nothing fighting back. Then somebody starts fighting back.

The knowledge bottleneck — what you cannot write down

You read ten handwritten digits in a second. Then try to write down the rule you used. The best hand-written rules score 24% where you scored 100%, and the reason is not a lack of effort.

From writing rules to learning them

Same digits, same pixels, same kind of rule. One thing changes: a program writes the rules instead of a person. It scores 82.8% against 24.2%, and it wrote 139 rules in a hundredth of a second.

Feature selection — which features earn their place

R² cannot go down when you add a column. So it cannot decide which columns to keep. Watch it climb on columns of pure random numbers, then meet the two scores that charge a fee for every column: adjusted R² and AIC.

Cross-validation — the honest number

Every score so far was measured on the markets the model was fitted to, and every one is therefore optimistic. Hold data back to find out by how much. Then find out why holding it back once is not enough.

Putting it to work — a forecast someone can act on

The whole path, turned into something a marketing lead can approve: which channel to cut, what next quarter will sell, how wrong that number will be, and the one experiment that would settle what no model here can.

Framing a regression problem — when the answer is a number

Regression predicts a number — sales, revenue, demand, days-to-close. What separates it from every other kind of prediction, why the decision has to come before the model, and the media budget we are going to spend this path explaining.

Exploratory data analysis — look before you fit

Four questions to ask a dataset before fitting anything to it — and the specific way each one saves you from a model that scores well and recommends the wrong budget.

Same agent, opposite outcomes

One canvas, one prompt, one model, two runs — and two different disasters, each rated 5/5 by the agent that caused it.

Four postures: deflect, assist, gate, human-only

The triage that decides how much authority an automation gets — and the axis every team skips.

Read the blast radius off the node itself

Reversibility is a field on every node, not a judgement call — and the one place it will still mislead you.

Why an ungrounded agent is fluently wrong

A fabricated fact arrives in the same register as a true one — and tightening the instruction makes the error better camouflaged, not rarer.

Your policy as a Knowledge Base

Load the rules the reviewer will later enforce — and meet two retrieval settings that do not do what they say.

Search KB vs RAG Query — and when each lies

Retrieval hands the agent a clause belonging to a different customer. One measured experiment shows what stopped it — and it was not the pipeline.

Let it read the real account

The policy is undecidable without the record. Give the agent the argument and never the query.

Tools with consequence: the three tiers

Decide what an agent may hold before it holds anything — and why withholding is a structure while instructing is a wish.

Pinned fields vs {{ai}} slots

A pinned field is not pinned until one line says so — verified both ways, including a read-only tool that performed a write.

It quotes the policy correctly, moves ₹1.2 lakh anyway, and rates itself 5/5

Run the unbounded agent yourself. Its reasoning is right, its tool call is not, and nothing downstream reads the reasoning.

Why the better model is not the fix

A stronger model changes how often you get a bad run. It changes nothing about what a bad run can do.

Separation of duties: decider ≠ executor

The flaw in every agent built so far is organisational, not linguistic — and it has the same fix in software as in a finance team.

Policy-as-code: the reviewer holds the thresholds

A second model that judges and never fixes, holding rules the proposer has never been told — and the thing it still cannot catch.

A typed verdict, not a paragraph

Make the verdict machine-readable so the decision is taken by a node — and meet the boolean that fails open on the approve branch.

The gate: Human Approval before anything happens

Where the gate sits, what an expired approval means, who actually gets asked, and how to make it fail closed.

The bounded correction loop, capped at 3

Carry the critique back and cap the rework — with the real run where attempt 1 was rejected 2/5 and attempt 2 approved 5/5.

The audit row you can defend

The node whose job is to prove what happened was the only broken node in the canvas — because it was the one behind the gate.

When one agent isn’t enough: give it an org chart

Four measurable symptoms of an overloaded agent, and why the answer is an organisation rather than a bigger brain.

Build the specialists with agent-as-tool

Wire narrow specialists under a manager that holds nothing — the one boundary in this course that a setting cannot undo.

Blast radius: who else must be told?

A relational question an entity search answered “nobody”, wrongly and politely — and the one join that found the account nobody asked about.

Capstone — The Cohort Desk, unaided

One brief, four rules of three different kinds, an empty canvas — and a self-check the reference solution itself failed.

Simple linear regression — the line

Fit one line to one channel, and read it the way a marketer does: the intercept is base sales, the slope is what a thousand dollars of TV actually buys.

R², RMSE and residuals — is it any good?

R², RMSE and MAE answer different questions, and one plot beats all three. What to quote to a colleague, and how to find out your model is wrong in exactly the place you spend the most.

Multiple regression — more than one thing matters

Radio and newspaper join the model. R² jumps from 0.61 to 0.90. And one of the three channels turns out to have been contributing nothing at all, which is the most useful thing this path has to say.

One brain, many doors: what a desk is

The four parts of a desk — knowledge, doors, a pipeline and an exit — and why the exit is a part rather than a failure.

Answer "is this for me" — and never invent a price

Build the enquiry agent, and make it refuse rather than approximate a fee. A fee is not prose.

The knowledge a desk actually needs

The editorial job: four content types, the line between prose and facts, and writing down what your knowledge base does NOT cover.

Teaching it to say "I don't know"

Confident wrongness is the default. A clean refusal and a handoff are designed behaviours — here is the instruction that produces them.

The same agent on chat, WhatsApp and a phone call

What each channel demands of you

The reference page: what you need before you can start, what the customer can do with your reply, and what each channel actually costs.

Remembering the conversation

Memory is a budget, not a virtue. Use it to resolve references — never to hold a fact.

Leave a trace — and don't create four of them

Upsert the contact so one student is one record — and see how an unguarded upsert quietly makes the record worse.

Move the deal: stages that mean something

A stage is a claim about reality. Set it from quoted evidence, and let a node refuse the ones the model only inferred.

Know when to stop: handing off to a human

A handoff a colleague can actually pick up: owned, dated, attached to the record, and carrying the context.

Book the call without double-booking

Reminders that stop when they should

The first irreversible step. Four state checks before a message exists — and the silent failure that made this build send to nobody.

The first 48 hours: verify, then watch for absence

Nobody writes in to say they paid and never started. Absence has to be computed — and it is the safest automation you will ship.

The buyer's view: who hasn't started?

The one report a corporate buyer actually wants, that almost nobody sends — and the situation it prevents.

Read the log, find the one that broke

One real execution log, one broken reference, and the debugging order that finds it in four steps.

Capstone: the desk, end to end

Build the whole thing in your own org — with a self-check made entirely of failures this course actually hit.

Day-one automations

Five things you could automate this week, deliberately different from each other — because the word covers a much wider range than most people assume.

Your first automation

Two nodes, and an email that nobody sent. Read it once here and the rest of the course is detail.

Your first AI agent

The same three parts as the last lesson, except the middle one decides what to do. That single difference is what separates a rule from an agent.

The canvas

One screen, six things worth knowing by name. Learn the names and you can follow any instruction in the rest of this course.

Build it yourself

Your first build. A lead arrives, a follow-up task appears against it, and nobody typed anything — two nodes and one connection.

Passing data with variables

One node reaching back for another node's value. It is the whole mechanism, it is three words long, and almost every workflow that misbehaves misbehaves here.

Configuring nodes right

A node on the canvas does nothing until it is configured. Three things cover almost all of it — and the builder will tell you which one you have missed, if you let it.

Variables in action

A template is a promise until the workflow runs. Then every node can show you exactly what arrived, what it was configured with, and what it produced.

Configuring workflow details

The last thing you do to a workflow, and the one that decides whether anybody — including you — can work out what it does in six months.

Database Change trigger

The workhorse trigger: run a workflow when a CRM record is created, updated or deleted. Watching the right fields, and the self-trigger loop that catches everyone once.

Segment trigger

Fire when a contact joins or leaves a segment. Why membership changes are different from field changes, and how to stop the same person triggering a run twice.

Due Time trigger

Fire relative to a date already on a record — fifteen minutes before a task is due, or a day after. How it differs from a schedule and from a delay.

User Message trigger

The entry point for chat: fire when someone sends a message. Keyword filters, and the conversation memory that turns single messages into a conversation.

WhatsApp Message Received

Start a workflow when a WhatsApp message arrives — with the conversation history already attached. Which node to actually place, and what WhatsApp requires before any of it runs.

Inbound Voice Call trigger

Answer the phone with a workflow. What fires before the call connects, what you know about the caller, and why this trigger has less time than any other.

Webhook trigger

Let another system start your workflow by posting to a URL. Where the URL comes from, how to read the payload, and how to find out what actually arrived.

Google Calendar trigger

React to meetings: booked, moved, cancelled, or about to start. The five events, the lead-time window, and why calendar triggers poll rather than arrive instantly.

Google Sheets trigger

Turn a spreadsheet into an input. What fires on a new or changed row, how to read the columns by name, and the polling interval that decides how fresh it is.

Click trigger

The trigger a person presses. How a button in the CRM starts a workflow on the record you are looking at, and why this is the easiest way to introduce automation to a team.

CRM Manager

One node reads and writes every object in your CRM. Entity plus operation plus data is the whole mental model — and the write path is a JSON string, not a form.

Contact Summary

The node that reads a contact's whole history — deals, tasks, notes, calls — and writes the brief a rep would otherwise assemble by hand. What it gathers, what it returns, and the one setting that is misspelled.

Segment Manager

Segments are how the rest of Expedify finds a group of people. This node is how a workflow puts someone in one, takes them out, or moves them between two — and how it asks whether they are already there.

Smart Charts

Hand it an array of records and it picks the chart. No prompt, no model, no chart-type argument — it reads the shape of your data and decides. What it can draw, and what it does when it cannot.

Text Response

The node that ends a chat workflow by saying something back. One textarea — and the templating inside it does less than its documentation claims, which is worth knowing before you rely on it.

Response Builder

Some answers are not sentences. This node stacks a reply out of text, tables, charts and alerts — and its real config shape is not the one its schema advertises.

Email nodes

Two nodes that put a message in someone's inbox — one address or a list of them. The body field takes real designer HTML, which is the part most people never try.

WhatsApp Output

Replying on WhatsApp is the one channel where the product can refuse to send. Learn the 24-hour window first; the node's six fields take ten minutes after that.

WhatsApp Question

The node that stops the workflow mid-run and waits for a person to answer. Give it options and each one becomes its own branch — which is how a WhatsApp flow gets built without a chatbot framework.

Campaign Send

Three nodes that make a campaign: who it goes to, what it says, and the send. The compliance filtering is the part you would otherwise have to remember every time.

Voice Response

Text Response, out loud. Three fields matter, and the one that decides whether you get audio at all defaults to a value that gives you none.

Voice Inbound Call

The phone rings and a workflow decides what happens next — an AI agent that already knows who is calling, or a transfer to a person. The node pauses the run for the length of the call.

Voice Outbound Action

Ringing someone is the one action in this course that can get an organisation in trouble. The node knows that — its compliance checks are on by default, and most of its settings exist to stop you.

Transfer Call

The node an AI agent reaches for when it is out of its depth. It is not wired into the workflow — it is handed to the agent as a tool, and the agent decides.

Google Calendar

One node, six operations, and the first time you meet the pattern: the operation you pick decides what the rest of the panel even is.

Google Sheets

The node that gets your data in front of people who will never open Expedify. Eleven operations, four of which turn a sheet into something you can update rather than only append to.

Google Docs

When the output is prose that a person has to read, edit and send. The trick is not generating the document — it is leaving the right holes in it.

Web Scraper

For the pages nobody built an integration for. Twenty-nine fields, because the open web does not cooperate — but four of them decide almost everything.

Web Search

Six fields, and two behaviours that are not in any of them: you do not choose the search engine, and a query that finds nothing is quietly replaced with a shorter one.

Document Parser

Turns a file into text a workflow can use. The two things to know are which eleven formats it accepts, and that rescuing a scanned PDF quietly costs you model tokens.

API Request

The node for everything the other twenty could not do. It is also the only one in this path that tells you plainly when it failed — and the only one that can do the same damage twice.

Condition

One yes/no question, two paths. How the Condition node compares a value, which of its 27 operators to reach for, and what happens when the variable it checks does not exist.

Multi-Condition Router

When two branches are not enough. How condition groups, output paths and boolean expressions let one field fan out to as many routes as you need — and which operators actually evaluate.

Loop

Do the same thing for every item in a list. The two loop modes, the two output handles, the variables available inside the body, and how to stop a loop early.

Delay

Pause a workflow — for a duration, until a date, or until a person does something. The ten delay types, how the pause is actually implemented, and the two ways it surprises people.

Custom Function

The escape hatch: run Python when no node does quite what you need. The function signature, how data gets in and out, what you may import, and why reaching for this too early is a mistake.

Human Approval

Stop the workflow and ask a person. The three input modes, what the reviewer sees, what your downstream nodes get back — and why the Rejected path must always be wired.

Workflow Call

Call one workflow from another, so a piece of logic lives in exactly one place. Declared inputs, binding values to them, loop mode, and the recursion guard.

SQL Builder

Compose a query by picking tables, fields and filters instead of writing SQL — then edit the SQL directly when the builder runs out. What `final_sql` is, and the one-way door beside it.

Database Query

Ask your organisation's own database a question no node quite answers. Read versus write mode, how results come back, and the safety rails worth keeping on.

Transform Data

Data rarely arrives in the shape you need. How Transform Data parses JSON that is wrapped in text, reshapes a payload, and why it beats a Custom Function for this job.

Set Variable

Give a value a name so the rest of the workflow can stop repeating a long reference. Variable scopes, where the value comes from, and when a variable is the wrong answer.

LLM Integration

One AI call — no tools, no loop. It is also the best place to learn prompting, because the whole node is the prompt.

Core Agent

Give it a goal and some tools and it works the problem — choosing, checking, choosing again. The configuration is mostly about where it has to stop.

Voice Agent

The Core Agent's brain, on a phone call. Sixty-seven fields, and the four that decide whether the caller stays on the line.

Create a Knowledge Base

A model knows everything in general and nothing about you. A Knowledge Base is where you put what only your organisation knows — and the way it gets chopped up decides whether any of it comes back.

Create a Knowledge Base with AI

The other way in, for content that is not already clean. It reads the source, rewrites it, and stores the rewrite — which is exactly what you want, right up until it is not.

Knowledge Base node

The node that puts your library in front of a workflow. Two numbers control how much it looks at and how much it hands back, and a third decides what counts as relevant at all.

What is a webhook

No hook, no web. One system sending a message to another the moment something happens — and the reason nearly every integration you will build works this way.

Incoming webhook

Publish a URL, hand it to somebody else's system, and have a workflow start the moment they use it. The interesting parts are the secret and what you do with a payload you did not write.

Outgoing webhook

The other direction, and it is not a node. Subscribe an external URL to things that happen in your CRM, and Expedify calls it — with retries, signatures and a delivery log you can read.

Webhook vs API Request

Three tools, one protocol. The only question that matters is who picks up the phone first — and the answer settles which one you need in about ten seconds.

Testing in the builder

Fire the trigger for real, then read what happened. Two surfaces show the same run from different angles, and one field in it answers most questions.

The executions panel

Every run this workflow ever did, kept. The logs panel tells you about the last one; this is where you find out whether it has been happening all week.

Rerun and Run From Here

You found the bug and fixed it. Re-firing the whole trigger to check costs another AI call, another API request and a CRM record you cannot get back — so do not.

AI-led debugging

A tab on every executed node that reads the run for you. It is genuinely fast, and the thing that makes it useful is knowing exactly how much of the run to show it.

WhatsApp support agent

Every piece in this course, assembled once: a message arrives on WhatsApp, an agent answers it from your own documents, and the reply goes back on the same thread.

Voice call agent

The same four-part shape as the WhatsApp agent, on a channel where nobody can wait two seconds and nothing can be edited before it is heard.

Google Calendar to tasks

Thirteen nodes and five branches, and nobody is going to walk you through it. That is the point of the last lesson: you already know every box.

Every Expedify trigger, and when to reach for it

All twenty trigger types, grouped by the six questions they answer, each pointing at the lesson that builds with it. A reference, not a lesson.

What automation actually means in Expedify

Triggers: the five ways a workflow starts

Anatomy of a node: one job, one form

Passing data between nodes

Adding logic: conditions and branches

Reaching your customer: messaging nodes

Bringing in AI: the Agent node

Go live — then adapt a real template