AI Automation Workflows I Built During My Internships (And What They Actually Save)

Automation Isn't Just an Enterprise Thing

I used to think "automation" meant giant enterprise RPA deployments with dedicated Centers of Excellence. Then I actually built automation workflows during my internships and realized the biggest wins come from small, boring, repetitive tasks that nobody wants to do by hand — reformatting a spreadsheet, moving data between two systems, or replying to the same kind of request for the tenth time that day.

As an RPA Developer Intern at Avent IQ and, before that, an AI Intern at Draskenlabs, I've spent real hours building, testing, and debugging automation that runs in production — not toy demos. Here's what I've learned about where automation actually pays off, with concrete examples from workflows I've built.

What I Actually Do Day-to-Day

At Avent IQ, my work centers on developing and maintaining RPA bots for business process automation. That means:

• Building bots using enterprise automation tooling to handle repetitive, rules-based tasks
• Monitoring bot execution in production and catching failures before they cascade
• Testing and debugging bots when a workflow breaks (which happens more than you'd think — a website changes its layout, a file naming convention shifts, an API times out)
• Writing and maintaining Process Definition Documents (PDDs) so the automation logic is documented and reproducible

Before that, at Draskenlabs, I worked on frontend development for CRM-based web apps and helped build an automation workflow using n8n to streamline task execution — that project was my first real exposure to connecting AI models into a visual workflow tool instead of writing everything from scratch in code.

The n8n Workflow Pattern I Keep Reusing

The workflow I built at Draskenlabs followed a pattern that shows up constantly in automation work: trigger → enrich/transform → decide → act.

Trigger (webhook / schedule / form submission)
    ↓
Data extraction / normalization node
    ↓
LLM or logic node (classify, summarize, decide)
    ↓
Conditional branch
    ↓
Action (update CRM, send notification, create record)

A simplified version of an n8n workflow node chain looks like this in JSON:

{
  "nodes": [
    {
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhook",
      "parameters": { "path": "task-intake", "httpMethod": "POST" }
    },
    {
      "name": "Normalize Data",
      "type": "n8n-nodes-base.set",
      "parameters": { "values": { "string": [{ "name": "status", "value": "pending" }] } }
    },
    {
      "name": "Classify with LLM",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": { "url": "={{$env.LLM_ENDPOINT}}", "method": "POST" }
    },
    {
      "name": "Route by Category",
      "type": "n8n-nodes-base.if",
      "parameters": { "conditions": { "string": [{ "value1": "={{$json.category}}", "value2": "urgent" }] } }
    }
  ]
}

The important part isn't the JSON — it's the shape of the thinking: every automation workflow is really just "catch an event, make a decision, take an action." Once you internalize that, most business processes start looking automatable.

RPA vs. AI Workflow Tools: When to Use Which

Working across both an RPA-heavy internship (Avent IQ) and an AI/workflow-heavy internship (Draskenlabs) taught me the two approaches solve different problems:

RPA (Automation Anywhere style) is best when:

• The task involves legacy systems without APIs (screen scraping, desktop apps)
• The process is strictly rules-based with no ambiguity
• You need an audit trail and a documented PDD for compliance

n8n / AI-workflow tools are best when:

• You need to connect modern SaaS APIs together
• Some step requires judgment (classifying text, summarizing content, extracting unstructured data)
• You want to iterate quickly without deep coding

In practice, the best automation stacks often combine both: RPA bots for the legacy/desktop parts of a process, and lightweight AI workflows for anything that requires understanding language or making a judgment call.

A Real Example: Bot Monitoring and Debugging

Part of my job at Avent IQ is monitoring bot execution in production. A pattern I run into constantly:

1. A bot fails silently because an upstream file format changed slightly (an extra column, a renamed field)
2. Without monitoring, this goes unnoticed until someone downstream complains
3. With monitoring in place, I get an alert, check the execution log, identify the root cause, patch the bot logic, and update the PDD to reflect the new expected input format

This is the unglamorous but critical part of automation work — building the bot is maybe 40% of the job; keeping it reliable in production is the other 60%.

Practical Lessons for Anyone Starting with Automation

1. Start with the boring, high-frequency task. The task you do every single day, even if it only takes 5 minutes, adds up to hours per month.
2. Document as you build. A PDD (or even a simple README) that describes trigger conditions, expected inputs, and failure modes saves enormous debugging time later.
3. Design for failure, not just the happy path. Every automation eventually hits malformed input — plan the fallback before it happens in production.
4. Pick the right tool for the step, not for the whole pipeline. Mixing RPA, n8n, and direct API calls in one pipeline is normal and often the most pragmatic choice.

Let's Talk Automation

If you're exploring how n8n, RPA, or AI-assisted workflows could remove repetitive work from your process, I'd be glad to talk through it. Reach me at rishabnishad22@gmail.com or on WhatsApp, or check out more of my work at rishab-nishad.vercel.app.