By the end of this guide you'll have one real AI workflow running on a task from your current job, a one-page teardown that documents it, and a short demo video — the exact artifact employers open before your resume. The work takes about ten hours across two to three weeks, most of it waiting for the workflow to break on real data. If you can't run it on real work for two weeks, stop here; a demo that never ran is not a portfolio piece.
Who this is for
This is for you if you have a job with at least one boring, repeatable task and you want proof you can apply AI to real work. You do not need to be an engineer.
It is not for you if you want a pure tutorial with no work attached, or if you are looking for a side income from an "AI automation agency" by next week. This guide builds a career artifact, not a business. If you want the hiring context first, read what employers actually mean by AI skills; if you want the pay context, read the AI Automation Specialist salary guide.
The path is well-worn. Liam Ottley, who now runs an automation channel with hundreds of thousands of viewers, opens his beginner's guide with the honest origin story: "Just two years ago, I taught myself how to build no-code AI automations without any prior experience." You are not starting a decade behind. You are starting one workflow behind.
The path: five steps
The path is five steps: pick a task, map it, build the smallest version, run it on real work, then publish the teardown. Here is the map before we go deep on each.
- 1Pick a task you own
Choose one boring, repeatable task from your real job. You understand it, you do it weekly, and nobody will mind if it gets faster.
- 2Map the before state
Write down every step, where time leaks, and where a human judgment call happens. The map is the first half of the artifact.
- 3Build the smallest version
One tool, one AI step, one human review point. Resist adding more until the simple version runs.
- 4Run it on real work
Use it for two to three weeks on live tasks. Watch what breaks. Fix it. This is the step everyone skips and the one that matters.
- 5Publish the teardown
One page plus a short Loom: before, after, what the AI does, what it can't, and one metric that moved.
Step 1: Pick a task you actually own
Pick a task you do every week, understand fully, and could explain to a new hire. The quality of the whole portfolio piece is decided here.
Good candidates are narrow and repetitive: weekly status reports, inbox triage, meeting notes into a CRM, expense categorizing, lead routing, content repurposing, first-draft replies to common questions. Bad candidates are vague ("use AI for marketing") or one-time projects with no repeat to measure.
The reason to pick your own job is judgment. You already know the edge cases, the exceptions, and the moment a human has to step in. That knowledge is what makes the workflow good — and it is exactly what employers are testing for in Automate Workflows with AI roles.
The common mistake here: automating something you don't really understand because it sounds impressive. A messy workflow you know beats a glamorous one you don't. The artifact this step produces: one sentence naming the task and why it is worth automating.
Step 2: Map the before state
Map the current process end to end before you automate anything. The map is the first half of your final artifact, so write it as if someone will read it — because they will.
For each step, note who does it, how long it takes, where the data lives, and whether it needs a judgment call. Mark the two or three places that eat the most time. Mark every spot where a human currently decides something a rule can't fully capture.
- I do my weekly report manually.
- It takes a while.
- AI could probably help.
- Pull numbers from 3 dashboards (20 min, copy-paste).
- Summarize wins and risks (30 min, judgment).
- Format into the team template (15 min, mechanical).
- Human decides what to flag to leadership (judgment, keep this).
The right-hand version already tells you where AI fits: the copy-paste and formatting steps are automatable, the "what to flag" step stays human. That split is the most valuable thing in the whole piece.
The common mistake here: mapping the process you wish you had instead of the one you run. Map reality, exceptions included. The artifact this step produces: a step-by-step before map with time costs and a clear human-judgment line.
Step 3: Build the smallest version that runs
Build the smallest version that does one useful thing: one tool, one AI step, one human review point. You can always add more after the simple version survives real use.
For most people the toolbox is small. Pick one no-code automation platform and one model API:
- n8n — open-source and self-hostable. Fireship's walkthrough (over a million views) calls it "an open-source, self-hostable automation tool," and its template library gives you a running start.
- Make or Zapier — hosted and fast to start if you don't want to self-host.
- Claude or OpenAI — the model API that does the actual classifying, drafting, or extracting.
Wire the automatable steps from your map. Put the AI in the steps that need language or classification. Leave the judgment step as a human approval. The goal is a workflow a teammate could understand, not the cleverest pipeline you can build.
The common mistake here: over-engineering. Five tools, three agents, and a vector database for a task that needed one prompt and a spreadsheet. The artifact this step produces: a working first version you can run on one real input.
Step 4: Run it on real work for two weeks
Run the workflow on live work for two to three weeks. This is the step that separates a portfolio piece from a demo, and it is the one almost everyone skips.
Most builds look perfect on the first input and fall apart on the fifth. Prompts drift. A PDF arrives in a format you didn't expect. The model confidently invents a number. Watch each failure, write it down, and decide whether to fix it, add a guardrail, or route it to a human. That log of failures and fixes is gold — it is the proof you can operate a system, not just start one.
Track one metric the whole time. Time saved per run, error rate, turnaround, or volume handled. One honest number beats five vague claims.
A real example of why this step matters: a status-report workflow that summarized three dashboards looked flawless for a week, then a dashboard quietly renamed a column and the model summarized stale numbers without flinching. The fix was not a bigger prompt — it was a check that paused the run and pinged a human when a source returned an unexpected shape. That fix is the most impressive sentence in the finished teardown, because it shows you design for failure, not just for the happy path.
Why spend one hour doing something when you can spend ten hours failing to automate it?
The joke is the point. The ten hours of failing is the part that teaches you the job — and the part you document. Owning the boring middle of a workflow is the core of Automating Workflows with AI.
The common mistake here: declaring victory after one good run. The artifact this step produces: a failure-and-fix log plus two to three weeks of a real metric.
Step 5: Publish the teardown
Publish a one-page teardown and a two-minute demo video. The artifact only counts when someone outside your head can see it.
Write it in plain language on a personal site, a public Notion page, or a GitHub README. Record a short Loom showing the workflow run on one real input. Use this structure:
# [Task] — automated with AI
## Before
- The process, step by step
- Time cost and where it leaked
- The one judgment call a human had to make
## What I built
- Tool: [n8n / Make / Zapier]
- AI step: [Claude / GPT] does [classify / draft / extract]
- Human review point: [what a person still approves]
## What it is NOT allowed to do
- [the guardrail]
- [where it escalates to a human]
## After
- Metric that moved: [X -> Y over N weeks]
- 2-3 failures I hit and how I handled them
## Demo
- Loom link (2 min, runs on one real input)That page is the whole point of the guide. It shows judgment (where AI does and doesn't act), reliability (failures handled), and outcome (a metric), which is more than most candidates with years of experience can show.
The common mistake here: leading with the tools. Lead with the metric and the judgment; the tools are a footnote. The artifact this step produces: a public teardown and demo you can link from any application.
Common mistakes (and the fix)
Most failed AI portfolios fail in the same handful of ways. Here are the seven that come up most, each with the fix.
- It's a demo, not a workflow. It ran once and never on real work. Fix: two to three weeks on live tasks before you publish.
- You automated something you don't understand. The edge cases bite you. Fix: pick a task from your own job.
- No human in the loop. Everything runs through the model, including the judgment call. Fix: keep a review or approval step and say so.
- Tools over outcomes. The write-up is a stack of logos. Fix: lead with the before/after metric; name tools once.
- You used data you shouldn't have. Confidential records in a personal project. Fix: synthetic or sample data, or written sign-off.
- Over-engineered. Agents and vector DBs for a one-prompt task. Fix: one tool, one AI step, then add only if needed.
- It's private. It lives on your laptop. Fix: publish a teardown and a Loom anyone can open.
| signal | weak | strong |
|---|---|---|
| scope | A one-off script or a tool demo. | A workflow run on real work for two-plus weeks. |
| framing | A list of tools and model names. | Before state, after state, and what changed for the user. |
| reliability | Only the happy path. | A logged failure list with how each was handled. |
| outcome | It feels faster. | One metric: X to Y over N weeks. |
Templates and tools
Everything you need is free or cheap to start. Use these directly:
- n8n templates — copy a workflow close to your task and adapt it.
- Make templates — hosted starting points if you don't self-host.
- Anthropic Claude docs and OpenAI docs — the model API quickstarts for the AI step.
- Loom — record the two-minute demo.
- The teardown template above — copy the
workflow-teardown.mdblock and fill it in.
Skip the paid "AI automation agency" courses while you build your first piece. The free templates plus one real task are enough.
What's next
Once you have one teardown, you are ready to apply, and you are one step from a second piece. Two moves from here.
Build a second workflow in a different shape — if the first was a drafting tool, make the next a review queue or a routing system. Three small, real teardowns read as a portfolio, not a fluke. Then take the language you used in your teardown into your resume and interviews, where it doubles as proof of the AI skills employers actually want.
When you are ready to look at live roles, scan Automate Workflows with AI jobs and read each listing for the workflow it owns, using the title decoder in AI job titles in 2026, decoded.
- Pick one weekly task you own and understand.
- Map the before state with time costs and the human-judgment line.
- Build the smallest version: one tool, one AI step, one review point.
- Run it on real work for two to three weeks and track one metric.
- Publish a one-page teardown and a two-minute Loom demo.
FAQ
What makes a good AI automation portfolio?
One real workflow that ran on live work for weeks, documented with a before/after metric and a logged list of failures you handled. Judgment and reliability matter more than the number of projects or tools.
Can I automate my current job without IT approval?
Build it with sample or synthetic data, or get explicit sign-off first. Never put confidential company records into a personal project. You can describe a real process in a teardown without exposing real data.
What tools should I use for an AI automation portfolio?
One no-code platform (n8n, Make, or Zapier) plus one model API (Claude or OpenAI) is enough for a first piece. Add a vector store or extra tools only if the task genuinely needs them.
How long does it take to build one?
About ten hours of work spread over two to three weeks. Most of that time is letting the workflow run on real work so you can catch and fix the failures that make it credible.
Do I need to code to build an AI automation portfolio?
No. No-code platforms cover most of it. Light scripting or API knowledge helps for edge cases, but the test is whether you can design a reliable system, not whether you write production code.
What if my automation is small?
Small is fine. A narrow workflow you actually ran and measured beats an ambitious one that only worked in a demo. Employers read for judgment and reliability, which a small real project shows clearly.
Takeaway
The best AI portfolio piece is the boring task you already do, automated and documented.
You don't need a new job, a course, or a clever idea to prove AI skills. You need one task you own, one workflow that survived two weeks of real use, and one page that shows the judgment behind it. Build that, publish it, and you stop telling employers you can apply AI — you show them.