From Setup Errors to Observability: My First Hands-On Experience with SigNoz

Dashboard:My Journey Installing Signoz Locally

When I first heard about observability, I thought it was just another way of monitoring whether an application was running or not. But while participating in the SigNoz Agentic AI Hackathon, I realized that observability is much more than checking if a system is alive. It is about understanding what is happening inside an application through logs, metrics, and traces.

Instead of only reading about observability concepts, I wanted to experience the complete process myself. My goal was simple: install SigNoz locally, explore its dashboard, and understand how developers use observability tools while building modern applications.

The journey was not completely smooth. I faced configuration issues, permission errors, and environment problems, but solving those problems helped me understand how different development tools work together.

Why I Chose SigNoz

Modern applications are becoming more complex. A single application may contain multiple services, databases, APIs, and external integrations. When something goes wrong, developers need answers:

• What happened?
• Where did the problem occur?
• Why is the application slow?
• Which service caused the failure?

This is where observability becomes important.

SigNoz provides a way to collect and visualize the three major observability signals:

• Logs — information about events happening inside the system.
• Metrics — numerical measurements showing system behavior.
• Traces — the complete journey of a request through different components.

For the hackathon, I wanted to get hands-on experience with these concepts instead of only learning them theoretically.

My Local Setup

I installed SigNoz on my Windows 11 laptop using a local development environment.

My setup architecture looked like this:

The main components were:

• Windows 11 as my operating system.
• Docker Desktop to run containers.
• WSL2 Ubuntu as my Linux environment.
• Foundry CLI to generate and deploy the SigNoz configuration.
• SigNoz components running through Docker containers.

Installing SigNoz Locally

The first step was preparing my environment.

I installed and configured:

1. Docker Desktop
2. WSL2
3. Ubuntu
4. Foundry CLI

After installing Foundry, I verified the installation:

Command - foundryctl version

Verifying Foundry CLI installation before deploying SigNoz.

Then I created my SigNoz configuration file and used Foundry to generate the deployment files.

Command - foundryctl cast -f casting.yaml

Initially,the deployment process generated the required files successfully,but when Docker tried to start the containers, I encountered an error.

The First Challenge:Docker Permission Error

The first major issue appeared when Foundry tried to start the SigNoz containers.

The error was:

permission denied while trying to connect to the docker API
at unix:///var/run/docker.sock

At first, I thought something was wrong with Docker installation. However, after debugging, I found that Docker itself was working correctly.

The actual problem was that my Ubuntu user did not have permission to access the Docker socket

I checked the Docker socket:

ls -l /var/run/docker.sock

The output showed:

srw-rw---- 1 root docker /var/run/dockerk.sock

This meant that only users inside the Docker group could access Docker.

I checked my gourps:

groups

My user was not part of the docker group.

To fix this, I added my user to the Docker group:

sudo usermod -aG docker $USER

After restarting the WSL session, Docker commands started working correctly:

I verified it using:

docker ps

This experience taught me an important lesson: installing a tool is not always enough. Understanding how different layers of the environment interact is equally important.

The Second Challenge:Connecting Docker Desktop With WSL2

Another important part of the setup was connecting Docker Desktop with my Ubuntu WSL environment.

Initially, Ubuntu could not communicate properly with Docker Desktop.

I checked my WSL distributions: wsl -l -v

The output showed:

Ubuntu    Running       2 

docker-desktop   Running      2

After enabling WSL integration in Docker Desktop settings, Ubuntu was able to communicate with the Docker engine successfully.

This helped me understand how Windows and Linux environments can work together for development.

Successfully Running SigNoz

After fixing the Docker permission issue, I ran the deployment command again:

foundryctl  cast -f casting.yaml

This time, SigNoz successfully download the required Docker images and started all services.

The running containers included:

• SigNoz server
• ClickHouse database
• PostgreSQL database
• OpenTelemetry Collector
• ClickHouse Keeper

I verified the running services using:

docker ps

SigNoz services running successfully through Docker containers.

The containers were healthy and running successfully.

Exploring the SigNoz Dashboard

After deployment, I opened SigNoz in my browser:

http://localhost:8080

I created my admin account and accessed the dashboard.

SigNoz dashboard after successful installation.

The dashboard helped me understand how observability data is organized.

Understanding Logs, Metrics, and Traces

Logs

Logs provide detailed information about events happening inside an application.

They help answer questions like:

• Did an error happen?
• What happened before the failure?
• What information was generated during execution?

Metrics

Metrics provide numerical information about system behavior.

Examples:

• Request count
• Response time
• Resource usage

Metrics are useful for identifying patterns and performance changes over time.

Traces

Traces show the complete path of a request through different parts of an application.

They help answer:

• Which component is slow?
• Where did the request spend most of its time?
• Which service caused the delay?

Understanding these three signals changed my perspective about monitoring applications.

What I Learned From This Experience

My biggest learning was that observability is not just about having dashboards. It is about understanding the complete story behind an application.

Before this experience, I thought monitoring mainly meant checking whether a service was running. After working with SigNoz, I understood that developers need deeper visibility into their systems.

Some important lessons I learned:

• Debugging setup problems improves technical understanding.
• Different tools often depend on each other working correctly.
• Logs, metrics, and traces provide different perspectives of the same system.
• Observability helps developers move from guessing problems to understanding problems.

My First Understanding of OpenTelemetry

During this setup, I also learned about OpenTelemetry, an open-source observability framework used to generate and collect telemetry data. SigNoz works with OpenTelemetry to receive traces, metrics, and logs from applications.

This helped me understand that observability is not only about a dashboard. The dashboard is useful because applications continuously send meaningful telemetry data through standards like OpenTelemetry.

Conclusion

Setting up SigNoz locally was my first practical step into the world of observability. What started as an installation task became a valuable learning experience about Docker, WSL2, OpenTelemetry, and modern monitoring practices.

The challenges I faced during setup helped me understand the importance of system architecture and troubleshooting.

This experience gave me the foundation to explore deeper topics like application monitoring and AI agent observability during the SigNoz Agentic AI Hackathon.

References and Further Learning

During this setup and learning process, I referred to the following official resources to understand SigNoz and OpenTelemetry better:

• SigNoz Official Website:
  https://signoz.io/
• SigNoz Documentation:
  https://signoz.io/docs/
• SigNoz GitHub Repository:
  https://github.com/SigNoz/signoz
• OpenTelemetry Official Documentation:
  https://opentelemetry.io/docs/
• OpenTelemetry GitHub Repository:
  https://github.com/open-telemetry
• Docker Documentation:
  https://docs.docker.com/

I am a Computer Science student exploring software development, cloud technologies, and observability. This article documents my first hands-on experience with SigNoz during the SigNoz Agentic AI Hackathon.