From Workflow Automation to Full Observability: Building an AI-Powered Incident Analyzer with n8n, Gemini, Open-Telemetry & SigNoz

Satvik Singhal — Sun, 26 Jul 2026 07:38:26 +0000

From Workflow Automation to Full Observability: How We Built an AI-Powered Incident Analyzer with n8n, Google Gemini, OpenTelemetry & SigNoz

Agents of SigNoz Hackathon 2026 | Team AIFleet

Track: AI & Agent Observability

Every workflow can automate. But can it explain itself?

When building automation, we usually celebrate when the workflow executes successfully. But what happens when it doesn't?

A failed API call, a timeout, an AI model returning an unexpected response, or a node silently stopping execution can leave developers searching through logs without a clear picture of what actually happened.

While building our hackathon project, we encountered exactly this problem. Our workflow automated incident analysis, but initially it was difficult to understand where failures occurred or how long each stage took.

That challenge led us to build Incident Observability Analyzer—an AI-powered workflow that not only analyzes production incidents but also makes the entire execution observable using OpenTelemetry and SigNoz.

By the end of this article, you'll see how we combined workflow automation, AI, and observability to build a production-ready incident analysis pipeline that is fully traceable from start to finish.

Meet Team AIFleet

👨‍💻 Satvik Singhal

GitHub: https://github.com/Satvik-Creations

👨‍💻 Jishnu Singh

GitHub: https://github.com/jis0607

For the Agents of SigNoz Hackathon, we wanted to explore a question that many automation developers eventually face:

How do you debug an automated workflow when the workflow itself becomes complex?

Our answer was to combine workflow automation with observability.

The Idea

Our project starts with a production incident.

Instead of manually reading logs, searching dashboards, and asking an LLM for suggestions, the workflow performs these tasks automatically.

The workflow:

receives an incident
analyzes it using Google Gemini
generates a structured incident report
exports execution telemetry
visualizes every important step inside SigNoz

The result is an automated incident analysis pipeline that is transparent rather than a black box.

Why We Chose n8n

One of our goals was to build something practical.

n8n made it easy to orchestrate different services without writing large amounts of boilerplate code.

Using visual workflows allowed us to focus on solving the engineering problem rather than building infrastructure from scratch.

The workflow coordinates multiple steps while keeping the overall design easy to understand and extend.

The Biggest Challenge: Observability

Ironically, building the workflow wasn't the hardest part.

Making it observable was.

Initially, we knew whether the workflow succeeded or failed, but we didn't have enough visibility into what happened between the trigger and the final response.

Questions like these became difficult to answer:

Which node consumed the most time?
Where exactly did execution fail?
Which operation should be optimized?
How does the execution flow look from start to finish?

This is where OpenTelemetry completely changed our approach.

Introducing OpenTelemetry

Instead of treating every workflow execution as a single event, OpenTelemetry allows each important operation to generate telemetry.

This telemetry can then be exported to an observability platform.

For us, that platform was SigNoz.

Instead of manually investigating logs, we could now visualize workflow execution through traces and metrics.

That was the turning point of the project.

Architecture

Production Incident
        │
        ▼
     n8n Webhook
        │
        ▼
 Workflow Automation
        │
        ▼
 Google Gemini
 Incident Analysis
        │
        ▼
 Structured Report
        │
        ▼
 OpenTelemetry
        │
        ▼
      SigNoz
 ├── Traces
 ├── Metrics
 ├── Logs
 └── Dashboard

The complete architecture diagram is available in our GitHub repository.

How the Workflow Works

Step 1 — Receiving an Incident

The workflow begins when an incident reaches the webhook.

This incident may include log messages, error descriptions, service information, or other operational details.

Step 2 — AI-Powered Analysis

The incoming data is processed using Google Gemini.

Rather than producing a generic explanation, Gemini generates structured observations such as:

probable root cause
incident severity
potential impact
suggested next steps

These responses are converted into a clean incident report.

Step 3 — Workflow Automation

n8n orchestrates the complete pipeline.

Each node performs a dedicated responsibility while passing structured data to the next stage.

This modular design makes the workflow easier to maintain and extend.

Step 4 — Exporting Telemetry

Every important stage generates telemetry.

Instead of treating the workflow as a black box, execution details become measurable and traceable.

This telemetry is exported using OpenTelemetry.

Step 5 — Visualizing with SigNoz

SigNoz receives the telemetry and provides visibility into the workflow.

If you're new to SigNoz, you can learn more here:

Official Website: https://signoz.io/
Documentation: https://signoz.io/docs/

From a single interface, we can inspect:

execution traces
workflow timing
node performance
execution duration
failures
overall execution flow

Seeing the complete workflow as a trace made debugging significantly easier than reading isolated logs.

What We Learned

Before this project, we viewed automation and observability as separate concerns.

This hackathon completely changed that perspective.

A workflow may successfully automate a process, but without observability it becomes increasingly difficult to operate in production.

Some of our biggest takeaways were:

Automation should always be observable.
Distributed tracing provides context that logs alone cannot.
Visualizing execution helps identify bottlenecks much faster.
AI workflows become easier to maintain when every step can be inspected.

What We'd Improve Next

Although the current version solves our primary objective, there are several exciting directions for future development.

We would like to add:

automated remediation workflows
Slack and Microsoft Teams notifications
historical incident analytics
anomaly detection
predictive incident analysis
support for multiple AI providers
richer dashboards with custom KPIs

Why This Project Matters

As AI-powered systems become more common, workflows will continue to grow in complexity.

Automation alone is no longer enough.

Developers also need confidence that they can understand, debug, and improve these workflows after deployment.

That is exactly what observability enables.

Instead of wondering why something failed, engineers can investigate the complete execution path and make informed decisions.

Acknowledgements

We would like to sincerely thank WeMakeDevs and SigNoz for organizing the Agents of SigNoz Hackathon and creating an opportunity to explore modern observability practices through hands-on development.

Special thanks to my teammate Jishnu Singh for his collaboration throughout this project. Building this together was an incredible learning experience.

Resources

🔗 Project Repository

GitHub Repository

https://github.com/Satvik-Creations/AIFleet-Incident-Observability

🎥 Demo Video

Watch the Complete Demo

https://drive.google.com/file/d/1KOht8MDn5cB7ryfHa0A4Nb1LGfxTMDrN/view?usp=sharing

📖 Official Documentation

n8n Documentation: https://docs.n8n.io/
Google Gemini: https://ai.google.dev/
OpenTelemetry Documentation: https://opentelemetry.io/docs/
SigNoz Documentation: https://signoz.io/docs/

Final Thoughts

This project started with a simple automation idea and evolved into something much more valuable.

We didn't just want an AI workflow that generated incident reports—we wanted one that could explain its own execution.

By combining n8n, Google Gemini, OpenTelemetry, and SigNoz, we transformed an automation pipeline into an observable system where every important step can be inspected, traced, and understood.

The biggest lesson we take away from this hackathon is simple:

Building intelligent systems is important. Building systems you can observe, debug, and trust is even more important.

Thank you for reading, and we hope our experience encourages more developers to make observability a core part of every AI workflow they build.

If you'd like to explore the implementation in more detail, feel free to check out the complete source code and documentation.

⭐ GitHub Repository

https://github.com/Satvik-Creations/AIFleet-Incident-Observability

🎥 Demo Video

https://drive.google.com/file/d/1KOht8MDn5cB7ryfHa0A4Nb1LGfxTMDrN/view?usp=sharing

Thank you for reading! Feedback and suggestions are always welcome.

Tags: #n8n #OpenTelemetry #SigNoz #AI #Observability #Hackathon #GoogleGemini #Automation

DEV Community: Satvik Singhal