Building a Telegram Bot for AI Workflow Notifications with n8n

The Problem: Automation That Runs Silently Isn't Trustworthy

When I built AI JobCopilot — a Chrome extension that extracts a LinkedIn job description and triggers an n8n workflow to generate a personalized recruiter email and ATS-optimized LaTeX resume — the automation itself worked fine within a day or two. The bigger problem was trust: an unattended pipeline that emails recruiters on my behalf, with no visibility into whether it succeeded, failed, or sent something malformed, isn't something I was comfortable running blind.

The fix was simpler than I expected: wire the Telegram Bot API into the n8n workflow, so I could both submit job descriptions from my phone and get real-time status notifications for every run. This post is a genuine walkthrough of how that integration works.

Why Telegram Over Alternatives

I considered a few notification channels before landing on Telegram:

• Email — too slow and noisy for something I want to glance at in seconds
• Slack — overkill for a personal project with no team to notify
• Telegram — a free, simple bot API, instant push notifications on phone and desktop, and — critically — the ability to receive input from me, not just send output to me

That last point mattered. I didn't just want notifications; I wanted to be able to submit a job description by pasting text into a Telegram chat when I wasn't at my laptop with the Chrome extension open. Telegram bots support both directions natively, which made it the obvious choice over a notification-only service.

Step 1: Creating the Bot

Telegram bot creation is entirely chat-driven through @BotFather:

1. Message @BotFather on Telegram
2. Send /newbot, choose a name and username
3. BotFather returns a bot token, e.g. 123456789:AAExampleTokenValueHere
4. Send a message to your new bot once, then hit https://api.telegram.org/bot<TOKEN>/getUpdates to retrieve your chat_id — this is what lets the bot message you specifically rather than broadcasting

Step 2: Wiring the Telegram Trigger in n8n

n8n has a native Telegram Trigger node that listens for incoming messages. This became the entry point for submitting a job description without opening the Chrome extension:

{
  "name": "Telegram Trigger",
  "type": "n8n-nodes-base.telegramTrigger",
  "parameters": {
    "updates": ["message"]
  },
  "credentials": {
    "telegramApi": "AI JobCopilot Bot"
  }
}

Any message sent to the bot lands here as $json.message.text, along with $json.message.chat.id — which I use later to route the reply back to the same chat.

Step 3: Branching on Message Content

Not every message to the bot is a job description — some are status check-ins ("status" to get the last run's result). I added an IF node to branch on intent:

{
  "name": "Is Job Description?",
  "type": "n8n-nodes-base.if",
  "parameters": {
    "conditions": {
      "string": [
        {
          "value1": "={{ $json.message.text }}",
          "operation": "notEqual",
          "value2": "status"
        }
      ]
    }
  }
}

If it's a job description, it flows into the same LLM generation pipeline that the Chrome extension triggers via webhook — meaning the extension and Telegram are just two different entry points into one shared workflow, not two separate systems to maintain.

Step 4: Sending Status Notifications Back

This is the part that actually solved my trust problem. At each meaningful stage of the pipeline — email generated, email sent, error encountered — I added a Telegram node that sends me a message using the chat_id captured earlier:

{
  "name": "Notify: Email Sent",
  "type": "n8n-nodes-base.telegram",
  "parameters": {
    "chatId": "={{ $json.message.chat.id }}",
    "text": "✅ Applied to {{ $json.company }} — {{ $json.jobTitle }}.\nRecruiter email sent to {{ $json.recruiterEmail }}."
  }
}

And critically, an error branch wired to n8n's error trigger, so failures are just as visible as successes:

{
  "name": "Notify: Error",
  "type": "n8n-nodes-base.telegram",
  "parameters": {
    "chatId": "={{ $env.MY_TELEGRAM_CHAT_ID }}",
    "text": "⚠️ AI JobCopilot workflow failed at node: {{ $json.node.name }}.\nError: {{ $json.error.message }}"
  }
}

That error notification alone changed how I trusted the system. Instead of periodically checking Google Sheets to see if applications were actually going out, I know within seconds if a run failed — and why.

Step 5: Closing the Loop — Application Logging

Every successful run also writes a row to Google Sheets (job title, company, timestamp, status) so I have a persistent record beyond the ephemeral Telegram notifications. The Telegram message is for immediate awareness; the sheet is for the searchable history. Keeping both meant I never had to choose between "know right now" and "look this up later."

What I'd Tell Someone Building Their First Bot Integration

A few practical lessons from actually running this in production for my own job search:

• Always capture chat_id from the trigger, don't hardcode it, unless you genuinely only ever want one fixed recipient. Capturing it dynamically means the same workflow could notify different users without duplicating nodes.
• Wire the error trigger from day one. A silent automation failure is worse than no automation at all, because you keep trusting output that stopped being generated.
• Use Telegram as an input channel, not just output, if your workflow has a use case for mobile-triggered runs. It's a small addition once the trigger node is already there, and it meaningfully increases how often you actually use the automation.

Building Your Own Notification Layer?

If you're building an n8n workflow and want to add Telegram (or another) notification and control layer to it, I'm happy to compare notes. Reach out at rishabnishad22@gmail.com or on WhatsApp, or see more of my automation work at rishab-nishad.vercel.app/#contact.