How to Choose Which Tasks to Automate with AI (A Scoring Framework)
By Abhishek Patoliya · 2026-09-29
Most failed automation projects did not fail because the technology was weak. They failed at the very first decision: someone picked the wrong thing to automate. The task was too rare to pay back the effort, or too risky to run unattended, or too dependent on knowledge nobody had written down, or already fast enough that the "saving" was imaginary. The workflow itself may have been built beautifully and then quietly switched off three months later.
Choosing well is a skill you can learn, and it is more valuable than any specific tool. This article gives you a repeatable method: how to inventory the work, how to score candidates, how to map a process so you see the exceptions before they hurt you, how to decide between automate, accelerate and keep-human, and how to estimate whether it is worth building at all. It uses no invented statistics; where numbers appear, they are illustrations you should replace with your own.
Start with the process, not the technology
The most common mistake is starting from a tool: "we have a model, what can we do with it?" That produces demos. The reliable approach runs the other way: "where does time, money or quality leak in our actual work, and is any of it automatable?"
A useful reframing: automation does not act on jobs, it acts on triggers, inputs, decisions and actions. Every process you might automate can be described with those four things.
Trigger: what starts the work. An email arrives, a form is submitted, a date passes, a record changes.
Inputs: the information that enters. Text, attachments, records, numbers, context in someone's head.
Decisions: the judgments applied. Classifications, priorities, approvals, "is this normal?" checks.
Actions: what gets done. Data entered, messages sent, records updated, files moved, people notified.
If you can describe a task in those four terms, you can reason about automating it. If you cannot, the task is not yet understood well enough to automate, and the first step is to understand it.
Build a task inventory
You cannot choose well from memory. Spend a week collecting data on real work.
Method 1: a task log. For five working days, keep a simple log. Each time you start a discrete piece of work, note what it was, roughly how long it took and how often it comes up. It is tedious and revealing. Most people are surprised that a handful of small recurring tasks add up to more time than the big projects they think about.
Method 2: calendar and inbox archaeology. Look through last month's sent mail and calendar. Recurring meetings, repeated email templates, "can you send me..." threads and weekly reports are all candidates.
Method 3: ask the team. Ask colleagues one question: "What do you do every week that you wish you did not have to?" The answers are usually specific and honest.
Method 4: follow the copy-paste. Any place where a person copies data from one system into another is a strong signal. Copy-paste is manual integration.
Aim for 20 to 40 candidate tasks. Write each as a short phrase with a rough weekly frequency and time per occurrence. Do not filter yet.
The seven criteria
Once you have a list, score each candidate against seven criteria. These are practical rather than theoretical; each one maps to a way projects go wrong.
1. Repetitive. Does it happen often enough that automating it pays back? A task done every day for a year justifies real engineering. A task done twice a year usually does not, however annoying it is.
2. Digital. Do the inputs and outputs already live in software? A workflow that starts with a paper form, a phone call or an in-person conversation needs a digitisation step first, which changes the economics.
3. Rule-based or semi-structured. Is there a discernible pattern, even if the input is messy? Language models excel at semi-structured input, such as emails that always contain a request but never in the same format. Tasks with no pattern at all, where every case is unique, are poor candidates.
4. Time-consuming. Is the total time significant? Multiply frequency by duration. Ten minutes, twenty times a week, is over three hours; that is worth attention.
5. Measurable. Can you tell whether the automation worked? If you cannot define what "correct" means, you cannot test or improve it. Good candidates have checkable outputs: the right category, the right field, the right recipient.
6. Connected. Can the systems involved be reached programmatically, through APIs, webhooks, database access or file exports? If a critical system offers no integration, you may be forced into brittle workarounds such as screen automation.
7. Low-risk or reviewable. What happens if the automation is wrong? If errors are cheap and reversible, or a human can review before anything irreversible happens, the task is a good candidate. If an error could harm a customer, breach a regulation or lose money that cannot be recovered, it needs review or should not be automated.
A scoring sheet
For each task, score 1 to 5 on each criterion, where 5 is most favourable. For risk, invert it: 5 means very low risk.
Task | Repetitive | Digital | Structured | Time | Measurable | Connected | Low risk | Total |
|---|
Tag incoming support tickets | 5 | 5 | 4 | 3 | 5 | 5 | 4 | 31 |
Extract fields from supplier invoices | 4 | 4 | 3 | 4 | 5 | 4 | 3 | 27 |
Draft weekly status report | 3 | 5 | 4 | 3 | 3 | 4 | 4 | 26 |
Negotiate a contract renewal | 2 | 3 | 1 | 3 | 1 | 2 | 1 | 13 |
Approve a large payment | 3 | 5 | 3 | 1 | 5 | 5 | 1 | 23 |
The numbers are made up to show the method. Two things are worth noticing. First, the total alone is not enough: "approve a large payment" scores respectably because it is digital, measurable and connected, but its risk score is 1, and that single low score should stop full automation. Treat any 1 on risk as a veto that turns the task into an "accelerate with human approval" candidate. Second, the ranking gives you a starting shortlist, not a verdict. Discuss it with the people who do the work.
Map the process before you touch a tool
A shortlisted task deserves a proper map, because most automation risk hides in the parts of a process people forget to mention. Sit with the person who does the work, ideally while they do it, and write down each step.
Use a simple table with these columns:
Step | Trigger | Input | Decision | Action | Exceptions |
|---|
Fill in the happy path first, then push on the exceptions with specific questions:
What happens when the input is missing something?
What happens when it is in a different format, language or channel?
What do you do when two rules conflict?
When do you ask someone else?
What is the most unusual case you have seen in the last year?
What would make you stop and not proceed?
What do you check that is not written down anywhere?
That last question is the important one. Experienced people carry unwritten checks: "I always double-check that customer, they have had billing issues," or "if the amount ends in .99 it is usually a duplicate." These are the rules an automation will violate on day one unless you capture them.
Draw the result as a flow with boxes for steps and diamonds for decisions. If the map takes longer than you expected, that is information: the process is more complex than assumed, and the automation will be too.
Automate, accelerate, augment or keep human
With the map in hand, decide what to do with each step, not just each task. A single process usually contains all four categories.
Automate when the step is deterministic or well-bounded and errors are cheap or catchable. Examples: moving data between systems, applying a fixed rule, sending a notification, creating a record.
Accelerate when a human should still own the outcome but the drafting or gathering can be sped up. Examples: a first draft of a reply, a summary of a long thread, pre-filled fields awaiting confirmation. The human reviews, edits and approves.
Augment when the automation gives someone a capability they lacked. Examples: searching across thousands of documents, monitoring many sources, summarising trends across a large data set.
Keep human when the step involves judgment with consequences, relationships, ethics, or accountability that must rest with a person. Examples: deciding a disciplinary outcome, delivering difficult news, approving an exception to policy.
A single "handle incoming invoice" process might split like this: extraction of fields is automate with validation, matching to a purchase order is automate, resolving a mismatch is accelerate (the system proposes a resolution and the person decides), approving an unusual amount is keep human, and reporting monthly variances is augment.
Notice how the categories interact with risk. The higher the cost of error, the further toward "accelerate" and "keep human" you should move.
Which parts need AI, and which do not
Once you know what to automate, decide what does the work. A frequent and expensive error is using a language model where a rule would do.
Use plain rules or scripts when the logic is fully specifiable: "if the amount exceeds X, route to finance," "if the file is a PDF, save it to this folder," "send the report every Monday at 8:00." Rules are cheap, fast, deterministic and easy to test. AI automation versus traditional scripting discusses the trade-off.
Use a language model when the input is unstructured or varied and the task is one of understanding: classifying free-text requests, extracting fields from inconsistently formatted documents, summarising, drafting, translating between formats, or answering questions from text.
Use retrieval when the model needs information it was not trained on, such as your policies or documents. RAG explained covers this.
Use an agent when the steps genuinely cannot be predicted in advance. This is rarer than the hype suggests; see agents versus workflows.
A useful rule of thumb: put AI at the edges of understanding (reading messy input, producing a draft) and deterministic code at the core of action (writing to databases, calling APIs, applying business rules). That is the design that tends to be easiest to test and safest to operate.
Estimate the value honestly
Before you build, estimate whether it is worth it. You do not need precision; you need to avoid self-deception.
Time saved per month = (occurrences per month) x (minutes per occurrence saved) / 60.
Be careful with "minutes saved." If a task takes 10 minutes and an automation reduces it to a 2-minute review, the saving is 8 minutes, not 10. If the automation is wrong 10 percent of the time and each error takes 30 minutes to fix, subtract that.
Value of that time. Multiply by a realistic hourly cost, but only count savings you will actually capture. Ten hours saved across ten people, each in small slices, may not translate into anything unless the time is redirected. Be honest about whether the time will be used for something valuable or just disappear.
Cost to build. Include design, building, testing, data cleanup and integration, and your own time even if it feels free.
Cost to run. Model usage, platform fees, hosting, and monitoring. For language model steps, estimate tokens per item and multiply by volume, using your provider's current published prices.
Cost to maintain. Prompts drift, APIs change, and business rules evolve. Budget ongoing time. Automation drift explains why workflows stop working.
Payback period = build cost / monthly net benefit. If the payback is more than a few months for a modest process, look for something better. How to calculate AI automation ROI and total cost of ownership go deeper.
Add non-financial benefits separately and modestly: faster response, fewer errors, better consistency, less tedium. They are real, but they are also easy to inflate.
Signs a task is a bad candidate
Some patterns should make you pause.
The rules are not written down and nobody agrees on them. If two experienced people would handle the same case differently, automating it will encode an argument.
The data is poor. If records are inconsistent, duplicated or missing, automation amplifies the mess. Clean the data first, or make data cleaning the project.
The volume is tiny. Rare tasks rarely justify the build and maintenance cost.
The process is about to change. Automating something that will be redesigned in three months wastes effort.
The error cost is high and review is impractical. If a mistake is severe and no human will realistically check, do not automate it fully.
The task depends on trust or empathy. Delivering bad news, negotiating, consoling, mentoring. A model can help prepare, but the human relationship is the task.
Nobody owns it. An automation needs an owner who will watch it, fix it and answer for it. Without one it will decay.
The pain is imaginary. If the task is quick and nobody minds it, there is no problem to solve.
Tasks that should not be fully automated
Some categories deserve particular caution.
Decisions with legal or significant personal consequences. Hiring, dismissal, credit, insurance, medical or legal decisions may be regulated in your jurisdiction and can affect people seriously. Keep a qualified human accountable, and check applicable law. Automation can prepare information and flag issues; the decision should sit with a person.
Irreversible actions. Deleting data, making payments, publishing publicly, sending mass communications. Put an approval step in front of them.
Sensitive communication. Complaints from upset customers, bereavement, disputes. The cost of tone-deafness is high.
Anything you cannot verify. If you cannot tell whether the output is right, you cannot trust it.
Data you are not permitted to send to a third party. Check contracts and regulations before sending personal or confidential data to an external API.
Anything where the model's input is untrusted and its output has power. If a system reads external emails or web pages and can take consequential actions, prompt injection becomes a serious risk. The OWASP Top 10 for LLM Applications (2025) lists prompt injection first (LLM01) and also lists excessive agency (LLM06), meaning granting more autonomy or permission than can be safely overseen. Constrain what such a system can do. See defending against prompt injection.
None of these mean "no AI." A model can draft, summarise and recommend while a person decides.
Choose a first project: a decision guide
If you are new, your first automation should teach you the most for the least risk. Look for a task that:
You or your team do at least weekly
Takes at least 30 to 60 minutes per week in total
Has digital input and output
Has an unambiguous notion of correct
Can be reviewed by a person before any external effect
Involves systems with APIs you can access
Has an owner who cares about the result
Strong first projects across many businesses include: triaging a shared inbox into categories with extracted fields, turning form submissions into CRM records with a draft reply for review, extracting data from standard documents into a spreadsheet, and drafting a weekly report from data you already have. AI email automation and intelligent document processing cover two of these.
Avoid as a first project: anything customer-facing and autonomous, anything involving money movement, anything requiring you to integrate five systems at once, and anything with a vague goal like "improve customer experience."
Define success before building
For your chosen task, write the success criteria before you open a workflow tool. Keep it to a page.
Baseline. Time per occurrence, occurrences per week, current error rate, current turnaround. Measure it, do not guess.
Target. What improvement counts as success. Use your baseline to set it, not a number from an article.
Guardrails. What must never happen (for example, no external message sent without review).
Review design. Which cases go to a human, and how.
Measurement plan. How you will sample outputs, how often, and who does it.
Kill criteria. Under what conditions you will switch it off. This is a sign of maturity, not pessimism.
Metrics that matter suggests which measures are worth tracking.
A worked example: choosing between three candidates
Imagine a small consultancy with three complaints.
Inbound enquiries arrive by email and web form. Someone reads each, enters details in a CRM and replies. About 40 per week, 8 minutes each, so roughly 5 hours per week.
Monthly client reports. An analyst pulls figures from three tools and writes a narrative. Twelve reports, about 2 hours each, so 24 hours per month.
Contract negotiation notes. Partners debrief after calls and write summaries. Ten per month, 30 minutes each.
Scoring against the criteria:
The enquiries are frequent, digital, semi-structured, measurable, connected through email and CRM APIs, and low-risk if replies are drafted for review. That is a strong candidate. The design is a workflow: form and email trigger, model extracts and classifies, rules score, CRM record created, reply drafted, human reviews. The AI sits at the edges; the actions are deterministic.
The reports are time-consuming and connected, and the numbers can be pulled with API calls with no model needed. The narrative is a strong "accelerate" candidate, where a model drafts commentary from the figures and the analyst edits. The number-pulling is pure automation. Overall, a good second project.
The negotiation notes are infrequent and highly sensitive. A model could transcribe and summarise calls, which would be an accelerate step, but confidentiality concerns mean checking data-handling terms and permissions before sending any of it to a third party. It is a poor first project.
The consultancy starts with enquiries, measures the baseline for two weeks (time per enquiry, error rate, response time), builds a version that drafts but never sends, and measures again. Only then does it consider the reports.
The point is the reasoning. Each decision came from criteria and a process map, not from what was technically fashionable.
Run a 90-minute selection workshop
If you are choosing on behalf of a team, a short structured session beats an email chain. A format that works:
Before the session (each participant, 15 minutes). Write down three recurring tasks they find tedious, with rough weekly frequency and time. Collect these in a shared sheet.
Minutes 0 to 15: frame the goal. State what the session is for (choose one or two candidates for a first automation) and what it is not (a headcount discussion). Saying that out loud changes the quality of the answers, because people talk more openly about tedious work when they are not worried about being measured for replacement.
Minutes 15 to 40: score together. Go through the shortlist and score each task on the seven criteria. Disagreements are useful. If one person says a task is rule-based and another says it depends on judgment, you have just discovered an unwritten rule or an inconsistency.
Minutes 40 to 65: map the top two. Pick the two highest scorers and map each with the trigger, input, decision, action and exception columns. Let the person who does the task talk while someone else writes.
Minutes 65 to 80: classify the steps. For each step, decide automate, accelerate, augment or keep human, and mark where a review is needed.
Minutes 80 to 90: decide and assign. Choose the first project, name an owner, agree what to measure for the baseline, and set a date to review progress.
Two rules keep the session productive: the people who do the work outrank the people who manage it on questions of how the work happens, and any task with a veto on risk gets discussed separately rather than argued about in the scoring.
Keep a backlog, not a wish list
Once you start looking, you will find far more candidates than you can build. Treat the list as a backlog and keep it healthy.
Record each candidate consistently: a one-line description, the owner, the frequency, the time per occurrence, the scores, the risk notes and the dependency on systems or data.
Rank by value over effort, adjusted for risk. A quick win with a clear baseline goes before a large, uncertain project. It builds credibility and teaches you about your own environment.
Revisit regularly. Tasks change, tools change, and something that was impractical last quarter may be easy now because an integration appeared or a data source got cleaned up.
Record decisions not to automate. A short note on why a task was rejected saves you from re-arguing it every few months and can be reversed if circumstances change.
Look for shared components. Many candidates need the same building blocks: reading an inbox, extracting fields, writing to the CRM, notifying a channel. Building these as reusable pieces makes each later project cheaper.
Three process maps, briefly
Seeing the mapping method applied in different settings helps. These are simplified illustrations.
Accounts payable: supplier invoice arrives by email.
Trigger: email with attachment arrives in the accounts inbox.
Inputs: PDF or image of the invoice, sender, purchase order number if present.
Decisions: is this really an invoice; which supplier; does it match an open purchase order; is the amount within tolerance; is it a duplicate.
Actions: record in the accounting system, route for approval, schedule payment.
Exceptions: no purchase order, amount mismatch, unknown supplier, duplicate invoice number, invoice in a foreign currency, credit note instead of invoice.
Classification: extraction is automate with validation; matching is automate; mismatch resolution is accelerate; approval above a threshold is keep human.
Recruitment: candidate application arrives.
Trigger: application submitted through the careers page.
Inputs: CV, cover letter, answers to screening questions.
Decisions: is the application complete; does it meet the stated requirements; who should review it.
Actions: record the applicant, acknowledge receipt, route to the hiring manager.
Exceptions: missing documents, unusual formats, duplicates, applications for roles that are closed.
Classification: acknowledgement and record-keeping are automate; summarising a CV against stated requirements can be accelerate but is a sensitive area, because decisions about people can be regulated and models can reflect bias in ways that are hard to see. Keep a human accountable for any selection decision, and check the rules that apply where you operate. See bias and fairness testing.
Customer support: a message arrives in the help inbox.
Trigger: new message or ticket.
Inputs: message text, customer identity, order and account history, relevant policy.
Decisions: what is the issue; how urgent; can it be answered from policy; does it need an exception or escalation.
Actions: categorise, set priority, draft a reply, escalate, or resolve.
Exceptions: angry customers, legal threats, multiple issues in one message, out-of-policy requests, messages in other languages.
Classification: categorisation is automate; drafting from policy is accelerate; exceptions and escalations are keep human. Human-to-AI agent handoff design covers the boundary.
Note how in each case the automatable core is a small part of the map, and the exceptions column determines the design.
Small business versus large organisation
The method is the same, but the constraints differ.
In a small business, the constraint is usually time and attention. Owners tend to do many tasks themselves, and the best candidates are often admin: enquiry handling, quoting, invoicing follow-ups, scheduling, review requests. Tool choice matters less than picking one narrow task and finishing it. The risk is sprawl: five half-built automations that nobody maintains. Build one, measure it, and keep it healthy before starting another. AI automation for small businesses gives examples.
In a larger organisation, the constraints are integration, security review, data governance and change management. A task that is trivial technically may take months to approve if it involves personal data. Involve security, legal and data owners early, and prefer candidates with limited data sensitivity for your first project. The AI automation governance framework explains how to structure approvals.
As a freelancer or agency, your risk is scoping. Clients often describe an outcome ("automate my lead handling") without a process. Do the mapping as a paid discovery step, agree measurable success criteria in writing, and be willing to recommend a smaller first phase than the client asked for.
When the answer is "fix the process first"
Sometimes the honest result of the exercise is that the task should not be automated yet. Warning signs include steps that exist only because of an old system limitation, approvals that nobody reads, reports that nobody uses, and handoffs that exist because two teams do not talk. Automating these entrenches waste.
A good test is to ask of each step: "if we were designing this from scratch today, would this step exist?" If not, remove it before automating. The cheapest automation is the step you delete.
It also helps to ask whether a simpler tool would do. A shared template, a checklist, a rule in your email client or a better form can remove much of the burden without any model. Recommending that is part of doing the job well.
Common mistakes
Automating the mess. If the underlying process is broken, automation makes it fail faster. Fix or simplify first.
Automating rare edge cases first. Handle the frequent cases and route exceptions to people. Do not chase the last 5 percent before the first 80 percent works.
Ignoring the humans. The people who do the work know the exceptions and will decide whether the tool is adopted. Change management matters.
Measuring activity, not outcomes. "The workflow ran 500 times" is not success. "Response time fell and errors did not rise" is.
Overestimating savings. Include review time, error fixing and maintenance.
Underestimating data work. Getting access, cleaning and mapping data often dominates the project.
Skipping the owner. Assign someone who is accountable for the automation after launch.
A one-page checklist
Before you build, you should be able to answer yes to most of these:
I can describe the trigger, inputs, decisions and actions.
I have mapped the process with someone who does it, including exceptions.
The task scores well on the seven criteria, with no veto on risk.
I know which steps are rules, which need a model, and which stay human.
I have a measured baseline.
I have estimated build, run and maintenance costs and a payback period.
There is a review step before any irreversible or external action.
The data I plan to send to a model is permitted to leave.
There is a named owner.
I know how I will measure success and when I would switch it off.
If you would like help mapping and scoring the tasks in your own business, get in touch.
Written by Abhishek Patoliya, Senior n8n Developer & Automation Architect, Surat, India. Verified n8n Creator.