How do you route customer email automatically? A five-step build with Jev and Zapier

Five steps cover the full build from idea to savings. The steps table shows 5 steps, from choosing the job to calculating savings. Each step has a timestamp, so a reader can jump to the exact part of the video and copy the move in the Zap editor.

A decision-only model is cheap at scale: four cents per million input tokens. At the price TypeSafe published as of recording, just over four cents per million input tokens, with no output-token charge at all because it never writes text.

Worked example: 165 hours back each month when routing removes three quarters of 220 hours. In the video, Nick works through an example of 220 hours a month spent sorting messages and 165 hours back once routing takes over most of that work.

What are the exact five steps Nick uses in the video?

Five steps, each with a timestamp you can jump to in the video, cover the complete build from scoping to measuring savings.

Sponsored by Zapier; see the video and the sponsor link for the integration.

What are the key moments and timestamps from the video?

The timeline helps you jump to the specific move you want to copy, from defining questions to setting the confidence floor.

The video runs 559 seconds; timestamps are from the published YouTube video.

What is Jev from TypeSafe, and why use it for email routing?

Jev is a model from a company called TypeSafe that does not write text at all.

Our first move is to pick the right kind of AI for the job. Models that write are helpful when you want a draft reply. Jev does one job: it reads an email, a ticket, or a form entry and returns a decision with a confidence score. That is the core of routing.

Those decisions come in the formats that match real work. Jev returns yes or no, one option from a set you define, or a rating on a scale you define. That makes it easy to map the answers to paths in your own tools. We are not asking it to write back to a customer. We are asking it to push the message to the right team on the first try.

In the video, Nick contrasts a writing model with Jev to set up the core idea. An AI that does not write text avoids long outputs you never needed and the cost of those output tokens. For routing, it is the right fit because you care about the same answer every time more than you care about style.

That is also why this guide stays small. You are not training a new system. You are asking a few clear questions and acting on the answers.

How do we sort customer email with AI in five steps?

Five steps, shown in the table above, take you from a list of messages to a live workflow in Zapier.

Step one is to choose the job and write down what you expect first. We take a few real messages from our inbox and decide what we want to happen to each one. We include a hard case with too little context, like "it happened again, please fix it." That written list is what we will test against later.

Step two is to tell Jev what to look for. Jev takes three kinds of question. Yes or no: does this message describe a problem that needs action today to prevent a business interruption? Pick one: which team should handle this, billing or tech support or sales or something else? Or a scale: how frustrated is this customer, from calm to furious. We define the questions and the possible answers, and Jev returns its choices with a confidence score for each.

Step three is to connect the answers to actions. In the Zap editor, we search for TypeSafe Jev, connect our account and select "Ask Questions." Then we use Zapier's Paths to send the work in different directions. An urgent technical problem opens a priority task for support. A billing question goes to accounts. A new lead goes to sales.

Step four gives Jev a way to ask for help. In the Zapier integration we set a minimum confidence level. Below it, the answer comes back as unsure. Then we either stop the workflow or branch to a person who can check the customer's history and route it properly.

Step five is to calculate what it saves us. We do it on both axes: staff time and the model charge. We are not paying for output tokens we never wanted.

How do we route support tickets automatically with Zapier and Jev?

Zapier Paths branch on Jev's answers so a support ticket moves to the right place as soon as it arrives.

We start with a trigger that pulls in each new message. Then the TypeSafe Jev step asks our questions and returns its decisions with confidence scores. From there, Paths opens a priority task for support when the message is an urgent technical problem. A billing question goes to accounts. A new lead goes to sales. No code, and no custom connection between the apps.

The piece that keeps trust high is the confidence floor. Anything below the threshold comes back as unsure and follows a human review path. That means a vague message like "it happened again, please fix it" does not end up in the wrong queue.

For a family business or a small team, this matters. It gives us fast routing for clear cases and a safe handoff for unclear cases. That protects our customers from being bounced around. It also keeps our staff from chasing work that is not theirs.

The build is one Zap. One trigger, one Jev step, and a set of paths. That is small enough to read in a minute and fix in a minute.

Which AI only makes decisions instead of writing?

Jev only decides; it will not draft a reply or produce any output tokens at all.

Those models generate text. Jev only decides. It will not draft your emails or write your essays, and it produces no output tokens at all, which is why it is cheap to run at volume. The tradeoff is that it only does the one job, so you use it where you want a decision rather than a document.

The timeline makes the money side concrete. The key moments table flags four cents per million input tokens with no output charge at 460 seconds, and $8.40 for 200 million tokens at 492 seconds. That shape of bill is only possible when the model does not write back.

For us, the steady result is the appeal. We control the questions, we control the paths, and we are not paying for written text we do not need.

If you do want a drafted reply later, that is a separate step with a separate tool. Keeping the two jobs apart is what makes each one easy to check.

Why does my email filter miss urgent messages?

Because they match words, not meaning.

Because they match words, not meaning. An ad reading "URGENT: forty percent off office chairs" contains the word a filter is looking for. An email reading "our whole team is locked out, we have a client presentation in two hours" does not. The filter flags the ad and drops the emergency, which is exactly backwards.

In the video, Nick opens with this contrast. The key moments table shows two emails arriving at 27 seconds and the filter missing the emergency at 49 seconds. That sets the rule we use to design our questions.

We ask exactly what we care about, such as "does this message describe a problem that needs action today to prevent a business interruption?" A vague instruction like "is this important?" leaves too much room for confusion.

For a parent running a business or watching a school program inbox, this means we stop guessing based on a single word. We route based on what the message means, not what it says.

What kinds of questions can Jev answer for routing?

Three types: yes or no, pick one from a list, or a rating on a scale.

Three. Yes or no, which is deterministic if-then logic. Pick one from a list of options you supply, such as billing, tech support, sales or other. Or a scale, such as how frustrated a customer sounds, from calm to furious. You set the questions and the allowed answers to fit your own workflow.

We design our core questions to match the queues we already have. One question can gate urgency. One can pick the team. One can set tone or priority. Because each answer comes back with a confidence score, we can treat low-confidence results as unsure and hand them to a person.

The steps table puts these questions in step two at 143 seconds. The key moments table lists the three answer shapes at 151 seconds. Both remind us to define the questions and the possible answers before we connect anything.

A short list of questions is easier to test. Start with the few that change where a message goes, and add more only when the inbox asks for them.

How do we test an AI routing workflow before going live?

We write down the answers we expect first, then compare Jev's answers against that list.

Write down the answers you expect before you build anything, using real messages your business received. Then feed those messages through and compare Jev's answers against your list. That is a real test. Reading the output and deciding it looks reasonable is not -- it is an eyeball test, and it will let bad routing through.

This fits step one in the table at 77 seconds and the follow-up at 98 seconds. Our test set includes a vague message like "it happened again, please fix it" so we see how the confidence floor behaves. We also include a mix of sales, billing, and technical cases so the pick-one question gets real coverage.

For a family, this lowers stress. We know before we turn it on that the common messages go to the right place. We also know the hard cases land in the unsure path for a person to review.

Keep the written list after launch. When a new kind of message shows up, add it and run the test again.

What should we do when the AI is not confident?

We set a minimum confidence so anything below it comes back as unsure and goes to a person.

You set a minimum confidence level in the Zapier integration, and anything below it comes back as unsure. From there you can stop the workflow or branch to a separate path where a person reviews the message, checks the customer's history and routes it properly. This is the step that keeps a low-confidence guess from landing in the wrong department.

In the steps table, this is step four at 301 seconds. The key moments table lists the unsure path at 328 seconds. A vague email like "it happened again, please fix it" could be a duplicate charge or a login problem, and there is no way to tell from the message alone.

This is where we build trust. We tell staff that the system asks for help when it is not sure. We give them a clean queue of only the cases that need human judgment.

Without this step, the workflow still runs. It just sends a weak guess somewhere wrong, and someone has to undo it later.

How do we connect Jev to our other apps in Zapier?

We use the native TypeSafe Jev step in Zapier and branch with Paths on the answers.

Zapier has a native TypeSafe Jev integration. Search for it in the Zap editor, connect your account, and select "Ask Questions." Then Paths branches the workflow on whatever Jev decided. There is no code and no custom connection to build between the apps.

This is step three at 249 seconds, with branching shown at 265 seconds. An urgent technical problem opens a priority task for support, a billing question goes to accounts, and a new lead goes to sales. The gain here is simple routing we can reason about.

Because the integration is native, we also get the confidence setting that feeds the unsure path. That closes the loop between the decision and the safeguard.

The video is sponsored by Zapier, and the call to action is to try Jev in Zapier. We say that plainly so you know where the link goes.

How much does Jev cost to run at volume?

At the price TypeSafe published as of recording, just over four cents per million input tokens, with no output-token charge at all because it never writes text.

On an example of roughly 200 million input tokens a month -- in the region of 100,000 emails -- that works out to about $8.40. Check the current published price before you plan around it.

We share these numbers to set expectations, not to make a promise about pricing. The key idea is that a decision-only model is cheap at scale because there are no output tokens at all. When we only need routing decisions, we do not pay for text we do not use.

For a parent leading a small team, that price shape means we can cover the whole inbox without fear of a surprise bill. We still keep an eye on usage, but the model choice removes a common source of cost spikes.

Prices change. Treat the figures in the key moments table as a snapshot from the video, not a quote for next month.

How much time can automated email routing save our team?

Worked through as an example: twenty people spending half an hour a day sorting messages, across twenty-two working days, is 220 hours a month.

If the workflow removes three quarters of that, the team gets 165 hours back, which at $50 an hour in staff costs is $8,250 a month, or $99,000 a year in time. Payroll does not shrink -- what changes is that those hours go to customers and leads instead of sorting.

We quote this math to help you size the impact. It connects the steps to a number you can discuss with your team. It also ties the build back to service: faster routing means faster help for real people.

If your inbox has a different volume or team size, the pattern still holds. The big savings come from removing the daily triage load.

The key moments table marks this stretch at 412 seconds and 426 seconds, so you can watch the math in order.

How do I write a good instruction for an AI classifier?

We ask the specific question we care about, not a vague one like "is this important?"

"Does this message describe a problem that needs action today to prevent a business interruption?" works. "Is this email important?" leaves far too much to interpretation, and you will get inconsistent answers because you asked an ambiguous question.

This shows up at 213 seconds in the timeline, where Nick explains why the vague instruction is a bad one. When we ask a clear yes-or-no tied to a business rule, Jev can decide the same way every time and give us a confidence score we can act on.

For families and small teams, this cuts rework. Clear questions mean clear paths. That is what lets a simple automation act like a calm teammate who does the same thing the same way, day after day.

Write the question the way you would say it out loud to a new hire. If a person would need to ask you what you meant, the model will struggle too.

How do we automate data entry and lead scoring as decisions?

We treat data entry and lead scoring as decision problems first, then let a normal automation do the typing.

Data entry is usually a decision problem wearing a typing problem's clothes. The hard part is not writing the value into a field, it is working out which field, which record, which team. A decision model answers that in about 200 milliseconds for a fraction of a cent, and an ordinary automation does the actual writing.

Jev is built for sorting customer requests, rating sales leads and deciding which department should handle a problem. So we ask it the same three kinds of question we use for email. Because Jev never writes text, there are no output tokens on the bill.

This lets us bring the same routing logic to leads, contact forms, and support emails. We get one steady way to decide what a message is and who should see it.

The safe unsure path comes along for free. Any message the model cannot place with confidence waits for a person instead of landing in the wrong place.

How do we start fast and keep it reliable over time?

We begin with the 5 steps, then revisit the test set and confidence floor as our inbox changes.

The steps as Nick lays them out in the video give us a reliable start: choose the job, define the questions and answers, connect actions, set the confidence floor, and measure savings. We then add new examples to our written test list when a new pattern shows up in the inbox.

Because Jev returns a confidence score for each answer, we can tune the floor without touching the rest of the build. If we see too many unsure cases, we can lower it a little. If we see wrong routes, we raise it. The safeguard stays in place either way.

The video runs 559 seconds, so a full rewatch is short. We find it useful to replay step four before we change the floor.

Our last piece of advice is to keep the build small. One trigger, one Jev step, a few paths, and a written list of expected answers is enough to run a clean inbox.

Method and sources: This guide is based on the video published on YouTube in 2026, which demonstrates routing customer email using Jev by TypeSafe inside Zapier. The population is a business inbox receiving customer emails, tickets, or form entries, and the outputs are routing decisions and confidence scores. Cost and time figures are those shown in the video and are examples, not guarantees, and pricing is as of recording. We exclude any task that requires the AI to write replies, and we do not change or estimate any numbers from the video; the video does not publish a response-time figure, so we do not give one. Rows in both tables come straight from the video, ordered by step number and by timestamp.