Design Your Automation — Sketch It on Paper Before Touching a Tool

OUTCOME — What You Will Have by the End

By the end of this tutorial, three things will sit on your paper and in your head.

What gets completed

• A list of 1 to 3 repetitive tasks you found inside your current workflow (e.g. "sending the same welcome message to every new signup")
• A pass/fail result for one of those tasks against an automation-candidate checklist
• A single sheet of paper with that one task sketched in the Trigger-Logic-Action shape

📖 Term: What is Trigger-Logic-Action This is the grammar of automation. The Trigger answers "when does this start?" (a form gets submitted, 6 AM arrives). The Logic answers "what gets decided in the middle?" (this email contains the word "urgent"). The Action answers "what happens as a result?" (a Slack notification is sent). Almost every automation in the world reduces to these three boxes. Complex automations are just multiple three-box chains linked together.

Meta info for this tutorial

Item	Value
Time	35 min (20 fast, 50 slow)
Level	Intermediate (thinking drill, no coding)
Tools	One sheet of paper + pen
Coding knowledge	Not required
Terminal use	None
Payment	Not required

Why this exists — in time terms

Most people learning automation start by watching Zapier or n8n tutorial videos. Drag and drop appears, pretty icons connect, they follow along. A month later they still have not automated anything in their actual work. The reason: they learned how the tool works but they do not know what to automate. This tutorial goes the opposite direction. Forget the tool names. First, build the eye that sees what inside your own work is worth automating. Once you have that eye, the tool choice becomes trivial.

Where you stand now: You have seen what this tutorial leaves you with. Next, confirm that the prerequisites are ready.

---

PREREQUISITES — What You Need

Only four things need to be ready.

Required

• A sheet of paper and a pen: One A4 is enough. A whiteboard or tablet works too. What matters is that you write by hand. Typing on a keyboard makes thinking too fast and you skip the structure
• Your current work situation: You need to recall tasks you repeated during the past week. A notebook or calendar will help
• 35 minutes of quiet time: Notifications off. If you get interrupted the pattern recognition breaks
• A logged-in AI tool: ChatGPT, Claude, or Gemini is fine. If you have none, finish Pick Your First AI Tool first in 20 minutes and come back

Not needed

• A Zapier, n8n, Make, Pipedream, or Latenode account (on purpose, we do not open them at this stage)
• Coding knowledge or programming experience
• A pre-built automation system

📖 Term: What is a repetitive task A "repetitive task" in automation terms is not simply "a task done many times." It is a task where inputs are similar and outputs are similar. "Send a welcome email to every new signup" qualifies: input (signup) is similar, output (welcome email) is similar. "Handle customer support" does not qualify in the simple sense: the input (content of the question) is different every time. This distinction is the first test for whether automation is even possible.

Environment check (2 min)

Draw these three boxes on your paper in advance.

┌─────────────┬─────────────┬─────────────┐
│  TRIGGER    │   LOGIC     │   ACTION    │
│  (when)     │  (how)      │   (what)    │
│             │             │             │
│             │             │             │
└─────────────┴─────────────┴─────────────┘

These empty boxes are today's destination. If they contain one of your real tasks 35 minutes from now, you succeeded.

Where you stand now: Paper, pen, and 35 minutes are secured. Next, a short WHY section on why we sketch on paper before opening any tool. You can skip it and still do the work, but reading it gives you a reference point three months from now when you scale the automation.

---

WHY — Why Design First, Not Tool First

A story from when I first ran my service.

At 10 users it was fine. Three questions a day, I answered each one directly, ten minutes total. It even felt good. I could sense that people were actually using the thing I made.

At 100 users it became 30 questions a day. Two hours, but still manageable. At 1,000 users it became 300 questions a day. I woke up and went to sleep answering messages. I could not do my main work, could not ship new features, and I broke down.

So I turned to automation. My first attempt was to open Zapier. I watched YouTube tutorials. Made an account, connected email, connected spreadsheets, built my first "zap." I worked hard on it, and the result was an automation that did not help my actual work at all. Because I had just copied the tool's example scenarios. I had never once looked at where my real time was going.

What happens when you open a tool before designing:

Symptom	Cause	Outcome
A pretty automation that never gets used	Automated a non-bottleneck	Zapier bill leaks money
Automation runs but work stays the same	Fake test trigger	Manual work still remains
Forget why the automation exists a month later	Designed inside the tool with no doc	No maintenance, gets deleted
Automation breaks and you can't tell where	T-L-A not separated	Back to doing it manually

Opposite side, what happens when you design on paper first:

Symptom	Cause	Outcome
Any tool works	Design is tool-agnostic	Zapier→n8n migration possible
Break points are obvious	You can name which of three boxes	10-minute fix
You can explain it to a teammate	One sheet of paper shares it	Automation becomes an asset
You do not build useless automations	Design step filters them out	Time and money saved

📖 Term: What does deterministic mean "Deterministic" means the same input always produces the same output. "Form submitted → add row to spreadsheet" is deterministic: same input (submission) always gives same output (one new row). "Resolve a customer complaint" is not deterministic: the same complaint can be answered many ways. Good automation candidates are repetitive AND deterministic.

That is why this tutorial does not open a tool first. On paper we break your work into three boxes. Work that does not cleanly break into three boxes is not an automation candidate. Work that does break into three boxes — from that point on, any tool will do.

Where you stand now: You have seen why design comes before tool. Next, actually find automation candidates inside your own work.

---

STEPS — The Actual Drill

Step 1 — List five repetitive tasks from the past week (8 min)

At the bottom of your paper, write down tasks you repeated two or more times in the past week. The list does not have to be perfect. Aim for five, but three is also fine.

My own list looked like this.

• Sending the same welcome message to every new signup (1-3 times a day)
• Answering "how do I change my password?" (10+ times a week)
• Summarizing the week's feedback and sharing it with the team every Friday (once a week)
• Moving product questions from Instagram DM to email to reply (5 times a week)
• Pulling sales data into Excel at the end of each month (once a month)

When writing:

Do	Do not
Write short verb+object ("send X to Y")	Write business categories ("customer care")
Note the frequency beside it ("10x a week")	Skip the frequency
Include tasks you are unsure about	Pre-judge whether it is automatable

Step 2 — Filter through the candidate checklist (7 min)

Filter your list for good automation candidates. Beside each item, ask four questions.

1. Is it repetitive? — Does it happen 2+ times a month. (One-offs do not get automated)
2. Is it deterministic? — Does the same input give the same output. (If creative judgment is needed, drop it)
3. Is it low-stakes? — Is a mistake non-catastrophic. (Money transfers and legal docs need more care)
4. Is it measurable? — Can you count "saved X minutes" after automating.

An item that gets yes on all four is a candidate. Any no drops it for now. A perfect candidate is not required. Today we pick just one.

My own table looked like this.

Task	Repetitive?	Deterministic?	Low-stakes?	Measurable?	Candidate?
Welcome KakaoTalk message	Yes	Yes	Yes	Yes	O
Password reset answer	Yes	Yes	Yes	Yes	O
Weekly feedback summary	Yes	No (judgment)	Yes	Yes	X
Instagram DM → email	Yes	Yes	Yes	Yes	O
Month-end sales pull	Yes	Yes	Yes	Yes	O

Out of the 4 that passed, pick the one that eats the most time. I picked "password reset answer": more than 10 times a week, 3 minutes each time, 30+ minutes a week.

Step 3 — Sketch the Trigger-Logic-Action boxes (15 min)

Return to the three-box drawing at the top of your paper. Fill your chosen task into those three boxes.

Fill the Trigger box (5 min): Answer "what makes this task begin?" It must be an observable event. "When someone needs help" is not a trigger — no system can observe that. "When a KakaoTalk channel message contains the word 'password'" is a trigger — a system can detect it.

Fill the Logic box (5 min): Answer "what decision is made after the trigger?" If no decision is needed, write "none." If there is one, write it in yes/no form. "Has this user already received this answer? If yes, skip. If no, proceed."

Fill the Action box (5 min): Answer "what happens after the logic passes?" Make it as concrete as possible. "Send an answer" is not enough. "Send a KakaoTalk message with the text: 'Password change is at Settings > Account > Password. Let me know if you need more help!'" is enough.

My own example.

┌──────────────────┬──────────────────┬──────────────────┐
│ TRIGGER          │ LOGIC            │ ACTION           │
│                  │                  │                  │
│ KakaoTalk        │ 1) Has the same  │ Send the stored  │
│ channel message  │    user already  │ answer template  │
│ containing       │    received      │ once:            │
│ "password"       │    an answer     │ "Password        │
│                  │    in last 24h?  │ change is at     │
│                  │ 2) If yes, skip. │ Settings >       │
│                  │    If no,        │ Account >        │
│                  │    proceed.      │ Password..."     │
└──────────────────┴──────────────────┴──────────────────┘

Step 4 — Get a review from AI (5 min)

Take your filled paper and either photograph it into AI (ChatGPT, Claude, or Gemini) or type it in. Paste this prompt.

"Below is my Trigger-Logic-Action design for an automation I'm planning. Review it on three points: (1) Is the trigger actually detectable by a system? (2) Are there exception cases missing from the logic? (3) Is the action concrete enough to be implemented as-is? Point out problems per box and suggest improvements.

[paste your three-box content here]"

The AI will catch exceptions you missed. In my case, the AI asked: "What if the same user asks a different question?" I added that condition to my logic box.

Where you stand now: One of your real tasks now sits on paper in a clean three-box shape. Next, verify whether this design is actually ready to be implemented.

---

VERIFICATION — Is This Design Actually Done

Filling three boxes is not enough. Four checks must pass before a design is ready to be moved into a tool.

Check 1 — Can a system observe the trigger

If the trigger is an unobservable event like "when someone is worried," it fails. It must be one of the following.

• A specific event (form submission, email received, payment completed)
• A specific time (daily 9 AM, every Friday at 5 PM)
• A specific condition (data exceeds X, a file appears in folder Y)

Observable vs unobservable:

Observable trigger	Unobservable trigger
When a new signup occurs	When someone is interested
When an email contains "urgent"	When a customer is angry
When it's Friday 5 PM	When the weekend is approaching
When revenue passes 1M KRW	When performance is good

Check 2 — Is the logic unambiguous

Logic must be a combination of yes/no questions. Vague phrases like "decide appropriately" fail. If the decision is complex, break it into multiple yes/no questions.

Check 3 — Is the action concrete

The action has to be concrete enough that whoever reads it can execute it directly. Not "send an answer" but "send a KakaoTalk message. Recipient: the user ID from the trigger. Body: template #3 as-is. Sender: official account."

Check 4 — Will you still understand this paper 10 minutes later

If you look at your design 10 minutes later and immediately think "right, this," it is done. If you do not understand it, the design is not done.

If all four checks pass, your design is an asset implementable by any tool. If a box fails, go back to Step 3 and rewrite only that box.

Where you stand now: Your design has passed verification. Next, look at variations so the same shape transfers to other contexts.

---

VARIATIONS — Applying the Shape Elsewhere

Your context may differ from my example. Here are four variations to calibrate your intuition.

Variation 1 — A solo creator

Box	Content
Trigger	A new subscriber submits their email on YouTube
Logic	Has this person received the welcome series before? If no, proceed
Action	Send welcome email #1 + schedule 7 daily tip emails at 9 AM

Variation 2 — An educator

Box	Content
Trigger	A student submits the assignment form
Logic	Is it before the deadline? If yes, mark "received." If no, mark "late."
Action	Send confirmation email + append submission to spreadsheet

Variation 3 — A small commerce operator

Box	Content
Trigger	An order payment is completed
Logic	Is the order amount 50,000 KRW or more? If yes, "VIP flag." If no, "regular."
Action	VIP → add to handwritten thank-you queue. Regular → send auto thank-you email

Variation 4 — Automation with an AI step inside (2026 standard)

As of 2026, Zapier, Make, n8n, Pipedream, and Latenode all ship AI steps or nodes as standard. Putting AI in the Logic box is now a drag-and-drop configuration, not a special skill.

If you put AI inside the Logic box of Trigger-Logic-Action, a simple automation becomes an intelligent one.

Box	Content
Trigger	A customer support email is received
Logic	AI step: classify the email as "refund / bug / feature request / compliment / other"
Action	Route to the assigned owner per category + log to spreadsheet

AI step availability by tool (April 2026):

Tool	AI capability
Zapier	AI Actions — instruct via natural language, fully mainstream
Make	AI Agents — multi-step autonomous execution, generally available
n8n	AI Agent node — LangChain-based, open source, free
Pipedream	AI embedded in code steps, developer-friendly
Latenode	No-code AI workflow builder, beginner-friendly

Comparison with the non-AI version:

Item	Without AI	With AI step
Logic complexity	10+ rules entered manually	One explanation to the AI
Exception handling	Unforeseen cases fall through	AI adapts
Maintenance	Rules constantly updated	Just tweak the prompt
Cost	None	A few cents per call

📖 Term: AI agent vs simple automation "Simple automation" is rule-based. "If X, then Y" is all it does. An "AI agent" has AI in the Logic box — it reads the situation and decides. As of 2026, Make AI Agents, n8n AI Agent nodes, and Zapier AI Actions make this a standard config in every major tool. Simple automation is brittle against exceptions. AI agents handle exceptions well but cost money per call. Start with simple automation for 80% of cases, add AI only for the exceptional 20%. That is cost-efficient.

Where you stand now: You have seen the same three-box shape working in several shapes. Next, common blocks people hit and what to do after this tutorial.

---

TROUBLE + NEXT — Common Blocks and What Comes After

Common block 1 — "I don't think I have any repetitive tasks"

You do. You are just so used to them that you no longer feel them as repetition. Ask these questions.

• Do you send the same email template 3+ times a week?
• Do you explain the same thing to multiple people multiple times?
• Do you move the same data from the same place to the same place on the same weekday?
• Is there a report you rebuild at the start of every month?

Any "yes" means there is a repetitive task hiding there.

Common block 2 — "My trigger keeps becoming vague"

Vague triggers come from starting too early in the timeline. "When a customer shows interest in my service" is too early. "When a customer submits a signup form" or "When a customer sends an email" works — those are the moments an observable trace hits the system.

Common block 3 — "My Logic box keeps coming out empty"

Some automations do not need logic. "Form submitted → append to spreadsheet" has "none" as its logic and that is fine. An empty Logic box is not a problem. Do not force content in. Logic-less automations are easier to implement.

Common block 4 — "I have too many actions to fit in one box"

If there are many actions, the correct move is to make two three-box designs. "Signup → welcome email" is one. "Signup → spreadsheet log" is another. Two automations branching from the same trigger. Do not cram them into a single Action box.

Common block 5 — "I'm not sure if this is really automatable"

If the four checklist items (repetitive / deterministic / low-stakes / measurable) all said yes, it is automatable. If you still doubt it, do it manually for one more week first. During that week you will catch "ah, this exception exists." Add that exception to your Logic box and move on.

Common block 6 — "Can I do this digitally instead of on paper?"

You can, but do it on paper the first three times. Typing makes your thinking too fast and you skip the three-box structure. Writing by hand slows the hand down, which slows the thinking down, which brings the structure back. After three rounds, Notion, Obsidian, or Figma all work.

NEXT — What to do after this

You have one design on paper now. I suggest three next steps.

1. Pick a tool — Choose from Zapier, n8n, Make, Pipedream, or Latenode. The free tier is enough. Here is the selection guide: beginners → Zapier (easiest, AI Actions now mainstream); want unlimited free self-hosting → n8n (open source, native AI Agent node); complex branching → Make (AI Agents generally available); developers → Pipedream; fastest no-code AI workflow experiments → Latenode.
2. Move the paper design into the tool — Place your three boxes as-is on the tool. Trigger block → Logic block → Action block. Even if the tool shows other capabilities, first reproduce the paper design exactly. Extensions come after.
3. Run for a week and review — Leave the automation on for a week, then answer three questions: (1) Did real time get saved? (2) How many times did it misfire? (3) Were new exceptions discovered? That review becomes the seed for the next automation.

A scaling question: If today's three-box design succeeds, can another three-box grow next to it? Automations do not increase one-by-one. They grow as multiple actions branching off the same trigger. One signup trigger can branch into a welcome email, a spreadsheet log, a Slack alert, and a 7-day tip series. Your three boxes are the root of one tree.

Automation is not a tool. It is a way of thinking. Once that way of thinking enters you, every system you build later will first be broken into these three boxes. That is the real asset.

┌─────────────┬─────────────┬─────────────┐
│  TRIGGER    │   LOGIC     │   ACTION    │
│  (언제)     │  (어떻게)   │   (무엇을)  │
│             │             │             │
│             │             │             │
└─────────────┴─────────────┴─────────────┘

┌──────────────────┬──────────────────┬──────────────────┐
│ TRIGGER          │ LOGIC            │ ACTION           │
│                  │                  │                  │
│ 카톡 채널에      │ 1) 같은 유저가   │ 카톡에 미리      │
│ "비밀번호"       │    24시간 내     │ 저장된 답변      │
│ 단어 포함        │    이미 답       │ 템플릿 1번 발송: │
│ 메시지 도착      │    받았는가?     │ "비밀번호 변경은 │
│                  │ 2) 받았으면      │ 설정 > 계정 >    │
│                  │    패스,         │ 비밀번호에서..." │
│                  │    안 받았으면   │                  │
│                  │    진행          │                  │
└──────────────────┴──────────────────┴──────────────────┘