Workflow Automator

The Workflow Automator skill identifies repetitive tasks and designs automated workflows using GitHub Actions, webhooks, MCP servers, and integration tools. It focuses on eliminating manual work, reducing errors, and accelerating delivery through intelligent automation.

This skill excels at analyzing existing processes, identifying automation opportunities, designing workflow diagrams, implementing automation scripts, and monitoring automated systems for reliability and efficiency gains.

Workflow Automator emphasizes pragmatic automation: automate what saves time, maintain what's automated, and keep humans in the loop for critical decisions.

Core Workflows

Workflow 1: Identify Automation Opportunities

Steps:

1. Process Audit

   • Map current workflows and process steps
   • Identify repetitive manual tasks
   • Measure time spent on each task
   • Document pain points and error sources
   • List all tools and systems involved

2. Automation Assessment

   • For each task, evaluate:
     • Frequency: How often is it done?
     • Volume: How many times per day/week?
     • Consistency: Same steps every time?
     • Rule-based: Can it be defined by logic?
     • ROI: Time saved vs. automation effort

3. Prioritize Automation

   • High priority: Frequent, high-volume, error-prone
   • Medium priority: Moderate frequency, clear rules
   • Low priority: Rare, complex, requires judgment
   • Calculate ROI: (Time saved per month) / (Build time)

4. Create Automation Roadmap

   • List automations by priority
   • Estimate build effort (hours)
   • Identify dependencies and prerequisites
   • Assign owners and timeline

Output: Prioritized automation backlog with ROI estimates.

Workflow 2: Design Automated Workflow

Steps:

1. Define Trigger

   • What event starts the workflow?
   • Examples: Git push, PR created, schedule, webhook, file upload
   • Specify trigger conditions and filters

2. Map Workflow Steps

   • List each action in sequence
   • Identify decision points (if/then logic)
   • Define parallel vs. sequential steps
   • Specify timeout and retry behavior

3. Define Data Flow

   • What data inputs are needed?
   • How is data transformed between steps?
   • Where is data stored or logged?
   • What outputs are produced?

4. Error Handling

   • What can go wrong at each step?
   • How should errors be handled? (retry, alert, skip, fail)
   • Who gets notified on failure?
   • What rollback procedures are needed?

5. Create Workflow Diagram

   • Visual representation of flow
   • Show triggers, steps, decisions, outputs
   • Document expected duration
   • Note dependencies and integrations

Output: Workflow specification document with diagram.

Workflow 3: Implement Automation

Steps:

1. Choose Automation Tool

   • GitHub Actions: CI/CD, git-triggered workflows
   • Webhooks: Event-driven integrations
   • Cron Jobs: Scheduled tasks
   • MCP Servers: AI-powered automations
   • Zapier/Make: No-code integrations
   • Custom Scripts: Specialized needs

2. Write Automation Code

   • Follow workflow specification
   • Implement error handling and logging
   • Add configuration for flexibility
   • Include documentation and comments
   • Write tests for automation logic

3. Test Automation

   • Test happy path (everything works)
   • Test error cases (failures, timeouts)
   • Test edge cases (empty data, duplicates)
   • Verify notifications and logging
   • Validate end-to-end flow

4. Deploy to Staging

   • Run in test environment first
   • Monitor for issues
   • Gather feedback from users
   • Adjust based on real-world behavior

5. Production Rollout

   • Deploy to production
   • Monitor closely for first 48 hours
   • Set up alerts for failures
   • Document runbooks for troubleshooting
   • Train team on automation

Output: Production-ready automation with monitoring and documentation.

Workflow 4: Monitor and Optimize

Steps:

1. Track Metrics

   • Execution count and success rate
   • Average duration and performance
   • Error rate and types
   • Time saved vs. manual process
   • Cost (compute, API calls, etc.)

2. Regular Reviews

   • Weekly: Check for failures and alerts
   • Monthly: Review performance and efficiency
   • Quarterly: Assess ROI and value
   • Yearly: Evaluate if still needed

3. Continuous Improvement

   • Identify optimization opportunities
   • Reduce execution time
   • Improve error handling
   • Expand automation coverage
   • Refactor for maintainability

Quick Reference

Best Practices

• Start small: Automate simple, high-ROI tasks first; build momentum with quick wins
• Make it reliable: 95%+ success rate minimum; unreliable automation is worse than manual work
• Design for failure: Assume everything can fail; handle errors gracefully and alert humans
• Log everything: Comprehensive logging enables debugging and auditing
• Keep it simple: Complex automations are hard to maintain; favor simple, modular workflows
• Version control: Store automation code in git; track changes and enable rollback
• Test thoroughly: Test happy path, error cases, and edge cases before production
• Monitor actively: Set up alerts and dashboards; know when automation breaks
• Document clearly: Future you (or teammates) need to understand what it does and how to fix it
• Maintain regularly: Review and update automations quarterly; remove obsolete ones
• Human oversight: Keep humans in loop for critical decisions; automation assists, doesn't replace judgment
• Measure impact: Track time saved and ROI; justify automation investment with data

Common Automation Patterns

1. CI/CD Pipeline

Trigger: Git push or PR Steps:

• Run linter and formatter
• Run unit and integration tests
• Build application
• Run E2E tests
• Deploy to staging
• Run smoke tests
• Deploy to production (on merge)
• Notify team on completion or failure

2. Issue Triage

Trigger: New GitHub issue created Steps:

• Analyze issue content
• Label by type (bug, feature, question)
• Assign to appropriate team
• Add to project board
• Notify team in Slack
• Auto-reply with acknowledgment

3. Dependency Updates

Trigger: Weekly schedule Steps:

• Check for package updates
• Create PR with updates
• Run full test suite
• Request review from team
• Auto-merge if tests pass and minor version

4. Performance Monitoring

Trigger: Every hour Steps:

• Check API response times
• Measure database query performance
• Analyze error rates
• Check resource usage (CPU, memory)
• Alert if thresholds exceeded
• Log metrics to dashboard

5. Customer Onboarding

Trigger: New user signup Steps:

• Send welcome email
• Create user account and resources
• Schedule onboarding emails (drip campaign)
• Add to CRM
• Notify sales team if enterprise plan
• Track onboarding completion

6. Backup and Archival

Trigger: Daily at 2 AM Steps:

• Backup database
• Backup uploaded files
• Compress and encrypt backups
• Upload to S3 or backup service
• Verify backup integrity
• Delete backups older than 30 days
• Alert if backup fails

7. Code Review Reminder

Trigger: PR open for 24 hours without review Steps:

• Identify pending PRs
• Check assigned reviewers
• Send reminder to reviewers
• Escalate if urgent
• Track review SLA metrics

8. Release Notes Generation

Trigger: Tag pushed (version release) Steps:

• Gather commits since last release
• Categorize changes (features, fixes, breaking)
• Generate release notes from PR descriptions
• Create GitHub release
• Post to changelog page
• Notify team and customers

Automation ROI Calculator

Time Saved Per Month = (Task Duration × Frequency per Month)
Build Time = Hours to implement + Hours to test + Hours to document
Payback Period = Build Time / Time Saved Per Month

Example:
- Task: Deploy to staging (30 min manual)
- Frequency: 40 times/month
- Time Saved: 30 min × 40 = 20 hours/month
- Build Time: 8 hours
- Payback: 8 / 20 = 0.4 months (12 days)
- ROI after 1 year: (20 × 12) - 8 = 232 hours saved

Rule of Thumb: If payback period < 3 months, automate it.

Automation Technology Guide

Error Handling Patterns

Retry Logic

- Transient errors: Retry 3 times with exponential backoff
- Rate limits: Wait and retry after delay
- Permanent errors: Fail fast and alert

Fallback Strategies

- Primary action fails: Try secondary action
- API unavailable: Use cached data
- Service down: Queue for later processing

Alerting Hierarchy

- Info: Log only
- Warning: Log and notify on-call during business hours
- Error: Immediate alert to on-call
- Critical: Page on-call and escalate to team lead

Integration Points

• GitHub Actions: Primary CI/CD automation platform
• Webhooks: Event-driven integrations with external services
• MCP Servers: AI-powered workflow automation
• Playwright MCP: Browser automation for testing and scraping
• Supabase: Database triggers and Edge Functions
• Slack/Discord: Notifications and bot commands
• Monitoring Tools: Sentry, DataDog, New Relic for observability