Why 90% of automation projects fail
It's not the technology that glitches. It's the choice of process.
Classic mistakes: automating something that looks easy but is actually full of exceptions — "send welcome emails to new customers" sounds trivial, but what counts as new? What happens during a test purchase? What if the customer already exists in the system? Every exception is a potential fail-point.
The second mistake is starting with the wrong question. The question isn't "what can we automate?" — that could be almost anything. The question is: which problem costs us the most per week?
Step 1: Identify the right process
Good automation candidates have four characteristics. Audit your processes against these:
Checklist for a good automation candidate:
- ✓ Repetitive — performed at least 2–3 times per week, preferably daily
- ✓ Rule-based — the logic can be written down in 10–15 sentences
- ✓ Time-consuming — takes 30+ minutes per run, or requires continuous attention
- ✓ Error-tolerant — a mistake doesn't cost more than it takes to undo it
Concrete examples that usually score high:
- Weekly competitive analysis — "collect what competitors posted on LinkedIn + the website, summarize in 5 points"
- Lead prioritization — "read incoming contact forms, classify hot/cold/spam, send hot leads to CRM"
- Invoice processing — "read PDF invoice, extract amount + supplier + date, log in accounting system"
- Weekly report to client — "summarize weekly activities from log data, generate report in the client's format"
- Job posting monitoring — "check JobTech/LinkedIn daily for new jobs in relevant categories, send brief"
Step 2: Choose the right architecture
There are three archetypes of AI agents, and choosing the wrong archetype is one of the most common reasons for exceeded budgets:
Archetype 1: Simple pipeline (recommended for starters)
Input → LLM → Output. No loops, no memory requirements. Example: "take this document → extract these fields → save as JSON". Cheapest to build and maintain. Rarely fails.
Archetype 2: Tool-calling agent
LLM with access to a set of tools — search, database reading, API calls, file system. The agent chooses which tools it needs and in what order. Suitable when the process requires information gathering from multiple sources. Claude 4 handles 15–20-step runs of this type without losing the thread.
Archetype 3: Multi-agent system
Several specialized agents with defined roles. A "manager" agent delegates to specialists. Suitable when the workflow is too complex for a single agent, or when parts can be run in parallel. Use only when the simpler alternatives are not enough — complexity increases exponentially.
Always start with the simplest archetype that solves the problem. You can always build out.
Daniel Merthen
Step 3: Stack selection — a concrete suggestion
There are hundreds of tools. This is the combination that works for most Swedish SME 2026, without requiring a full-time technician:
| Storage | Tools | Price/month |
|---|---|---|
| Orchestration | n8n Cloud | SEK 0–250 |
| LLM — cloud | Claude API (Anthropic) | SEK 50–500 |
| LLM — local | Ollama + qwen2.5:32b | Electricity cost (~SEK 50) |
| Storage | Notion / Airtable / PostgreSQL | SEK 0–200 |
| Notifications | Slack / Telegram / email | 0 SEK |
Total: SEK 100–1,000/month depending on volume. Compare this to outsourcing the same work manually — often SEK 5,000–20,000/month.
Step 4: Build — the minimum prototype pattern
The fastest way to validate an automation is to build a "pen-and-paper" flow first:
- Describe the trigger — what starts the run? (time, webhook, new file, form)
- List input data — exactly what information is available when the process starts?
- Write the LLM prompt — describe the task, define the exact output format
- Define the output action — where should the result go? (email, database, Slack, file)
- Identify 3 edge cases — what happens if input is empty? Wrong format? Duplicate?
Run the whole thing manually once with a real test case before connecting the automation. It reveals 80% of bugs.
A concrete example: lead prioritization
Let's put together a complete workflow. Scenario: a consultancy firm with 5 employees receives 15–20 contact forms per week. Half are spam bots or completely wrong segments. The right customers get lost in the noise.
Trigger: New webhook post from contact form (Typeform, Gravity Forms, etc.)
n8n-step 1: Extract name, company, message, email
n8n-step 2: Claude API call with this prompt:
You are a business developer at an AI consulting firm.
Classify this incoming lead:
Name: {namn}
Company: {company}
Message: {meddelande}
Return JSON:
{
"classification": "HOT | COLD | SPAM",
"reason": "short explanation (max 2 sentences)",
"priority": 1-5,
"suggested_next_step": "concrete action"
}
n8n-step 3: If classification = HOT → add to HubSpot/Pipedrive + send Slack notification
n8n-step 4: If COLD → add to automatic nurture sequence
n8n-step 5: If SPAM → remove, log for pattern recognition
Build time: 2–3 hours. Monthly cost: under 100 SEK (Claude API calls for 20 leads/week cost approximately 3–5 SEK). Time savings: 2–4 hours per week.
Step 5: GDPR — what applies to agents?
The Swedish Authority for Privacy Protection (IMY) has during 2026 clarified its view on AI agents and personal data. Three things to keep in mind:
- Legal basis is required. Every time your agent processes personal data (name, email, behavioral data) you need a legal basis. Most common for business agents: legitimate interest (Article 6.1.f GDPR). You must document the balancing of interests.
- Storage is the most dangerous point. If the agent logs personal data to "keep as reference" without a clear purpose limitation — that is a problem. Define exactly what is saved, why, and for how long.
- Local models simplify things. If your agent runs a local LLM (Ollama, LM Studio) no personal data leaves your network. This eliminates the entire issue of third-country transfers and data processing agreements.
An agent that handles personal data without a documented legal basis is a liability risk that is easy to avoid — and hard to explain afterwards.
The GDPR perspective
Step 6: Measure the right things
Most automation projects are measured on the wrong metrics: "running without errors" is not a KPI.
Define three metrics before you launch:
- Time saved/week — how many hours were freed up?
- Error rate — how often does a human need to intervene?
- Business outcome — what happened with the actual problem? (more qualified leads, shorter response times, etc.)
Set a threshold: if the error rate exceeds X % or the business outcome did not improve within 4 weeks — revise the agent. Automation without measurement is a hobby project.
Common pitfalls
- Automating chaos — if the process is chaotic manually, automation solves nothing. Clean up the process first.
- Prompt fragility — a prompt that works 90% of the time fails 10% of the time and no one notices until damage is done. Test with at least 20 real cases.
- Alert fatigue — if the agent sends notifications for everything, people will turn them off. Only send notifications that require action.
- Too much autonomy too soon — let the agent suggest during the first 2 weeks; approve manually; automate the approval once you see it is reliable.
Want to get started? Read the guide AI agents in your business — from idea to deployment for a more detailed roadmap, or dive deeper into what AI agents actually are if you are new to the concept.