Designing Your First Automation

From Map to Reality

In the previous lesson, we explored thinking in workflows: triggers, actions, conditions. Now let’s build on that foundation. In Lesson 2, you learned to map workflows with triggers, actions, and conditions. Now it’s time to take one of those maps and turn it into a detailed specification that you could hand to anyone (or any tool) and they could build it.

We’ll walk through the complete process using a real example: automating a weekly client status report.

What You’ll Learn

By the end of this lesson, you’ll turn a workflow map into a detailed automation specification, identify the data sources and integrations you need, and create a testing plan for your automation.

From Building Blocks to Blueprint

Lesson 2 gave you the vocabulary. This lesson gives you the grammar. You know what triggers, actions, and conditions are – now you’ll learn how to arrange them into a complete, buildable design.

Step 1: Document the Manual Process

Before automating anything, write down exactly how you do it manually. Every click, every decision, every piece of data you look at.

Our example: Weekly client status report

Here’s the manual process:

1. Open project management tool (Monday.com/Asana/Jira)
2. For each active client project, note: completion percentage, tasks completed this week, upcoming milestones, blockers
3. Open the shared spreadsheet with client contact info
4. Open email, create a new message for each client
5. Format the status update with their specific data
6. If there are blockers, add a section asking for their input
7. If a milestone is coming up next week, add a reminder
8. Review each email for accuracy and tone
9. Send
10. Log that the report was sent in the project tracker

Time: About 45 minutes for 8 clients.

Pain points: Repetitive formatting, easy to miss a client, tone varies depending on how tired you are, sometimes forget to log it.

Quick Check

For your automation candidate, have you documented the manual process in this much detail? If you skipped steps or said “then I just do the thing,” go back and be more specific. Those vague steps are where bugs will hide.

Step 2: Identify the Automation Components

Now translate the manual process into automation language:

Trigger: Every Friday at 10 AM (time-based)

Data sources:

• Project management tool (project status, tasks, milestones, blockers)
• CRM or spreadsheet (client names, email addresses, preferences)

Actions:

1. Pull project data for all active clients
2. Pull client contact information
3. For each client, generate a formatted status email
4. Send the email
5. Log the send event in the project tracker

Conditions:

• IF project has blockers → include a blocker section requesting client input
• IF milestone is due next week → include a milestone reminder
• IF no updates this week → send a brief “no changes” message instead of a full report

Outputs:

• Emails sent to each client
• Send log updated in project tracker

Step 3: Define the Minimum Viable Automation

Don’t try to build everything at once. Start with the simplest version that provides value, then add complexity.

Version 1 (MVP):

• Trigger: Manual button click (not time-based yet)
• Action: Pull data from project tool for ONE client
• Action: Generate formatted email draft (not auto-sent)
• Action: Display draft for human review

Version 2 (Add iteration):

• Process ALL active clients in a loop
• Generate all drafts at once

Version 3 (Add conditions):

• Include blocker and milestone logic
• Handle “no updates” case

Version 4 (Full automation):

• Time-based trigger (Friday at 10 AM)
• Auto-send after brief review window
• Log sends automatically

This incremental approach means you have a working automation after Version 1 – even if it’s not fully automated. Each subsequent version adds capability without risking what already works.

Step 4: Write the Specification

Here’s where AI becomes invaluable. Use it to help you create a detailed spec:

I'm designing an automation for weekly client status
reports. Here's my workflow:

Trigger: Every Friday at 10 AM

Data sources:
- Project management tool: project name, completion %,
  tasks completed this week, upcoming milestones, blockers
- CRM: client name, email, communication preferences

For each active client:
1. Gather project data
2. Check for blockers (if yes, include input request)
3. Check for upcoming milestones (if yes, include reminder)
4. Generate formatted status email
5. Send email
6. Log in project tracker

Create a detailed automation specification including:
- Exact data fields needed from each source
- Email template with dynamic fields
- Condition logic in pseudo-code
- Error handling (what if data is missing?)
- Success criteria (how to know it worked)
- Testing plan

Sample specification output (abbreviated):

AUTOMATION: Weekly Client Status Report
VERSION: 1.0
TRIGGER: Time-based, Friday 10:00 AM EST

--- DATA REQUIREMENTS ---

From Project Tool:
  - project_id (string)
  - project_name (string)
  - client_id (string, links to CRM)
  - completion_percentage (integer, 0-100)
  - tasks_completed_this_week (array of strings)
  - upcoming_milestones (array: name, date)
  - blockers (array: description, severity)

From CRM:
  - client_name (string)
  - client_email (string)
  - contact_first_name (string)
  - preferred_tone (enum: formal, casual)

--- WORKFLOW ---

STEP 1: Query project tool for all active projects
  Error: If API unavailable → retry 3x, then alert admin

STEP 2: For each project, query CRM for client details
  Error: If client not found → skip, log warning

STEP 3: Apply conditions
  IF blockers.length > 0:
    template = "status_with_blockers"
  ELSE IF upcoming_milestones within 7 days:
    template = "status_with_milestone"
  ELSE IF tasks_completed.length == 0:
    template = "brief_no_changes"
  ELSE:
    template = "standard_status"

STEP 4: Generate email using selected template
  Insert: client name, project data, personalization

STEP 5: Send email
  Error: If send fails → queue for retry, alert admin

STEP 6: Log send event
  Record: client_id, timestamp, template_used, status

--- SUCCESS CRITERIA ---
- All active clients receive an email
- Email content matches project data
- Correct template selected based on conditions
- All sends logged in project tracker

Step 5: Plan Your Data Connections

For each data source in your automation, you need to answer:

Common connection methods:

• API: Direct, real-time connection. Best for tools with good APIs (Slack, Salesforce, most modern SaaS).
• Webhook: The source tool pushes data to your automation when something happens. Real-time, but requires the source to support webhooks.
• Scheduled export: Pull data on a schedule (daily CSV export, weekly database query). Not real-time, but works with older systems.
• Manual input: Someone provides data via a form or spreadsheet. Simplest to set up, but adds human dependency.

Step 6: Design Your Templates

For automations that produce content (emails, reports, messages), design the templates in advance:

Design an email template for a weekly client status report.

Variables available:
- {client_first_name}
- {project_name}
- {completion_percentage}
- {tasks_completed} (list)
- {upcoming_milestones} (list with dates)
- {blockers} (list)

Create 4 template variants:
1. Standard update (normal progress, no blockers)
2. Update with blockers (needs client input)
3. Update with upcoming milestone
4. Brief no-changes message

Tone: Professional but warm. Concise.
Length: Under 200 words per variant.

Good templates have clear variable placeholders, handle empty data gracefully (what if tasks_completed is empty?), and sound natural despite being generated.

Putting It All Together

Your complete automation design package includes:

1. Process documentation – The manual process, step by step
2. Workflow map – Visual representation with triggers, actions, conditions
3. Specification – Detailed technical description of each component
4. Data connection plan – How you’ll access each data source
5. Templates – Any content your automation will produce
6. Testing plan – How you’ll verify it works
7. Version roadmap – MVP → full automation in defined stages

This might feel like a lot of upfront work. It is. And it saves you three times as much work during building and debugging. Automation projects that skip design and jump straight to building almost always take longer and produce worse results.

Exercise: Write Your First Spec

Take one automation from your opportunity list and create:

1. A detailed manual process document (every step)
2. A workflow map (trigger, actions, conditions)
3. A minimum viable automation definition (simplest useful version)
4. Data requirements (what data, from where, in what format)

Use AI to help fill gaps and identify things you’ve missed.

Key Takeaways

• Always document the manual process in detail before designing the automation
• Start with a minimum viable automation (MVP) and add complexity incrementally
• Write a specification that includes data requirements, conditions, error handling, and success criteria
• Plan data connections for every source your automation needs
• Design content templates with clear variables and graceful empty-state handling
• The design phase saves three times its investment during building and debugging

Next lesson: let’s build one of the most common automation types – email and communication workflows.