Modern applications don't just need features—they need observability.

When an API becomes slow, a database query takes too long, or an unexpected error occurs, developers need answers quickly. That's where SigNoz and OpenTelemetry come in.

For the Agents of SigNoz Hackathon 2026, I integrated SigNoz into my existing MERN Stack e-commerce application called Ram Store and transformed it into a fully observable application.

In this blog, I'll walk through what I built, how I instrumented it, the challenges I faced, and what I learned.

About the Project

Ram Store is a full-stack e-commerce platform built using the MERN Stack.

Features

  • User Authentication
  • Product Management
  • Categories & Subcategories
  • Shopping Cart
  • Address Management
  • Order Management
  • MongoDB Database

Tech Stack

  • React (Vite)
  • Node.js
  • Express.js
  • MongoDB
  • Docker
  • OpenTelemetry
  • SigNoz
  • Winston Logger

Why Observability?

Before integrating SigNoz, I could only rely on:

  • console.log()
  • Manual debugging
  • Browser Network tab

When something failed, I had questions like:

  • Which API is slow?
  • Why is the response delayed?
  • Which MongoDB query is taking time?
  • How many requests is my backend serving?
  • Where exactly did the error happen?

Without observability, finding answers takes time.

I wanted a single place where I could monitor everything.

That's why I chose SigNoz.

Setting Up SigNoz

I self-hosted SigNoz locally using Docker.

Once all the containers were running successfully, the dashboard became available.

After the initial setup, the next step was instrumenting my backend.

Integrating OpenTelemetry

I added OpenTelemetry to my Node.js backend.

Using the Node SDK together with automatic instrumentation, I configured:

  • Express instrumentation
  • HTTP instrumentation
  • MongoDB instrumentation
  • OTLP gRPC exporter

Now every request automatically generates telemetry without modifying every route.

Distributed Traces

One of my favorite features is Distributed Tracing.

Whenever I perform an action in Ram Store—like opening products or adding items to the cart—SigNoz automatically captures a trace.

Each trace includes:

  • Request Duration
  • API Execution
  • Database Operations
  • HTTP Calls
  • Complete Request Lifecycle

Instead of guessing where performance issues exist, I can now see the complete execution path.

Metrics

SigNoz also collects runtime metrics automatically.

Some of the metrics I monitored include:

  • API Request Count
  • HTTP Request Duration
  • Throughput
  • Memory Usage
  • Garbage Collection
  • Node.js Runtime Metrics

I also created custom application metrics to monitor request activity.

Watching these update in real time was a great learning experience.

Structured Logging

Observability isn't complete without logs.

I integrated Winston Logger into my backend.

Instead of relying on console.log(), my application now produces structured logs for:

  • Server Startup
  • API Requests
  • Errors
  • Important Business Events

These logs can be searched and correlated with traces inside SigNoz.

Service Overview

SigNoz provides a dedicated Service page where I can monitor:

  • Request Rate
  • Latency
  • Error Rate
  • Response Time
  • Overall Service Health

This gives a quick overview of how my backend is performing.

Challenges I Faced

This project taught me much more than simply installing a monitoring tool.

Some challenges included:

  • Installing SigNoz locally with Docker
  • Configuring OpenTelemetry
  • Exporting traces correctly
  • Forwarding telemetry
  • Understanding auto instrumentation
  • Integrating structured logging
  • Troubleshooting Docker networking issues

Each challenge helped me understand how production observability works.

What I Learned

Before this hackathon, I had almost no practical experience with observability.

Now I understand:

  • Distributed Tracing
  • Metrics Collection
  • Structured Logging
  • OpenTelemetry
  • Production Monitoring
  • Service Health Monitoring

This project gave me hands-on experience with tools used in real production environments.

Future Improvements

I plan to continue improving this project by adding:

  • Custom Dashboards
  • Alert Rules
  • Business Metrics
  • Error Monitoring
  • Performance Optimization
  • AI-powered Observability

Why I Recommend SigNoz

What impressed me most about SigNoz is that it brings everything together.

Instead of using different tools for:

  • Logs
  • Metrics
  • Traces

Everything is available in one platform.

That makes debugging much easier and faster.

Conclusion

Participating in the Agents of SigNoz Hackathon 2026 was an amazing learning experience.

By instrumenting my existing MERN application with OpenTelemetry and SigNoz, I transformed it into an observable application capable of monitoring every request, every metric, and every important event.

This project also helped me understand how modern production systems are monitored and why observability is essential for every developer.

A big thank you to SigNoz and WeMakeDevs for organizing this hackathon and encouraging developers to learn production-grade observability.

🔗 Project Links

GitHub Repository: https://github.com/RAMKUMAR0096/agents-of-signoz-hackathon

Demo Video: https://youtu.be/aN7EexyDEu8?si=UgTLd0zu-vvhYJD4