Introduction

As a student, I've built many projects that worked perfectly on my laptop. But one question always stayed in my mind:

"How will I know if my application is healthy after deployment?"

During this hackathon, I got the opportunity to learn something completely new—Observability.

So, I decided to build ApexVoter, a secure online voting system, and integrate SigNoz with it to monitor what happens inside my application while it's running.

This blog is not just about my project. It's about what I learned, the problems I faced, and how SigNoz helped me understand my application better.

💡 Why I Built ApexVoter

Online voting systems need to be reliable and secure.

If a voter clicks the Vote button and something goes wrong, the administrator should know immediately.

I wanted to build a project that not only allows users to vote securely but also lets the administrator monitor the application's performance in real time.

That is where SigNoz came in.

🛠 Tech Stack

Frontend

• HTML

• CSS

• JavaScript

Backend

• JSP

• JDBC

• Apache Tomcat

Database

• MySQL

Observability

• OpenTelemetry Java Agent

• OpenTelemetry Metrics API

• SigNoz Cloud

✨ Features of ApexVoter

The project includes:

• Secure Login

  

• OTP Verification

• Voter Registration

• Candidate Registration

• Election Management

• voter Dashboard

• Vote Casting

• Result Publishing

• Administrator Dashboard

• Real-Time Monitoring using SigNoz

🌟 What is SigNoz?

Before this hackathon, I honestly had no idea what observability meant.

I used to think checking logs was enough.

After learning SigNoz, I understood that observability is much more than logs.

It helps us understand what is happening inside an application while users are using it.

With SigNoz, I could monitor:

• Application requests

• Response time

• Errors

• Traces

• Metrics

• Dashboards

• Alerts

Instead of guessing why something was slow, I could actually see it.

That was one of the biggest things I learned during this project.

🔍 Integrating SigNoz

I integrated my JSP application with SigNoz using the OpenTelemetry Java Agent.

Whenever my application runs, telemetry data is automatically collected and sent to SigNoz Cloud.

This allowed me to monitor the health of my application without changing much of my existing code.

📊 Dashboards I Created

One of my favorite parts of this project was creating dashboards.

I built dashboards to monitor different parts of my application, including:

• Vote Processing Latency

• Login Latency

• Total Requests

• Error Requests

• OTP Verification Performance

These dashboards helped me understand how my application behaves while users interact with it.

Instead of looking through logs, I could simply open the dashboard and immediately understand the application's health.

🚨 Creating Alerts

I also created alert rules inside SigNoz.

The alerts notify administrators whenever:

• Vote processing becomes slow

• Login requests become slow

• Too many errors occur

This makes the application much easier to monitor.

📈 Custom Metrics

I also tried creating my own custom metric called:

votees_cast_total

The idea was simple.

Every time a user successfully casts a vote, the counter should increase.

Although I successfully implemented the metric in my code, I faced some issues while visualizing it inside SigNoz.

I spent a lot of time debugging dependencies, OpenTelemetry libraries, Maven packaging, and deployment.

Even though I couldn't fully visualize the metric the way I expected, the experience taught me a lot about how custom telemetry works.

Sometimes the biggest learning comes from debugging.

Challenges I Faced

This project was definitely not smooth from the beginning.

Some of the issues I faced were:

• Configuring Maven in an existing JSP project

• Missing OpenTelemetry dependencies

• Database connection issues

• Deploying libraries correctly inside Tomcat

• Creating custom metrics

• Understanding traces and dashboards

📚 What I Learned

This hackathon introduced me to an area of software development that I had never explored before.

I learned:

• Why monitoring is important

• How OpenTelemetry works

• How SigNoz collects telemetry

• How to create dashboards

• How to configure alerts

• How traces help debug applications

More importantly, I learned that building an application is only half the work.

Monitoring it is equally important.

What I'll Do Next

Although I learned a lot during this project, I know there is still much more to explore.

I want to improve my understanding of:

• Custom Metrics

• Better Alert Configurations

I also plan to integrate SigNoz into my future Java projects because I now understand how valuable observability is for real-world applications.

This hackathon was just the beginning of my observability journey.

❤️ Final Thoughts

Before this hackathon, I had never worked with observability tools.

Today, I understand why companies monitor their applications and how tools like SigNoz make debugging and performance analysis much easier.

Building ApexVoter was a wonderful learning experience.

It wasn't just about creating an online voting system—it was about learning how to make an application more reliable, observable, and production-ready.

I'm excited to continue learning and use SigNoz in many more projects in the future.

Thank you, SigNoz, for introducing me to the world of observability!

🔗 Project Links

GitHub Repository: https://github.com/jahnavichalla19-Jaanu/ApexVoter

Demo Video: https://youtu.be/2DWP4Ywa5Cc

SigNoz Dashboard Screenshots: