Instrumenting My MERN E-Commerce Application with SigNoz: From Zero to Full Observability

Ram Kumar — Sun, 26 Jul 2026 18:20:23 +0000

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

DEV Community: Ram Kumar