DEV Community: Yamini Kotturi

# Building InterviewIQ AI: Using SigNoz and OpenTelemetry to Observe an AI Interview Platform

Yamini Kotturi — Sat, 25 Jul 2026 12:30:46 +0000

Building InterviewIQ AI: Using SigNoz and OpenTelemetry to Observe an AI Interview Platform

Introduction

Modern AI-powered applications are becoming increasingly complex. While building intelligent features is important, understanding how those features behave in production is equally valuable. During the Agents of SigNoz Hackathon, I built InterviewIQ AI, an AI-powered interview preparation platform that not only evaluates candidates' answers but also demonstrates how observability can improve debugging, monitoring, and overall application reliability.

This project gave me an opportunity to explore OpenTelemetry and SigNoz while building a real-world application. Instead of treating observability as an afterthought, I integrated it into the application to monitor API performance, identify failures, and better understand how requests flow through the backend.

The Problem

Many students preparing for technical interviews struggle to receive meaningful feedback after answering interview questions. They may practice coding or theory, but they often lack an intelligent system that evaluates their responses and highlights areas for improvement.

I wanted to build a platform where users could:

Select an interview domain and difficulty level.
Answer technical interview questions.
Receive AI-generated evaluation and feedback.
Track strengths and weaknesses after the interview.

While building these features, I also wanted to understand what happens behind the scenes whenever the AI evaluates an answer. This is where observability became an important part of the project.

Project Overview

InterviewIQ AI simulates a technical interview experience.

The workflow is straightforward:

The user signs in securely.
An interview type and difficulty level are selected.
Technical questions are displayed one at a time.
The user submits answers.
The backend sends the response to the Groq AI model for evaluation.
AI-generated feedback, strengths, weaknesses, and scores are returned.
The interview summary is stored for future reference.

This project combines AI with observability, allowing both the interview experience and backend operations to be analyzed.

Tech Stack

The application was built using:

React + TypeScript
Express.js
Node.js
Supabase Authentication
Supabase Database
Groq API
OpenTelemetry
SigNoz

Each technology serves a different purpose, from user authentication to AI evaluation and monitoring backend performance.

Integrating OpenTelemetry

To understand how requests move through the application, I integrated OpenTelemetry into the Express backend.

The backend creates spans for major operations involved in evaluating interview answers.

Examples include:

Receiving the evaluation request.
Building the AI prompt.
Sending the request to the Groq API.
Parsing the AI response.
Returning the evaluation to the frontend.

Each span represents one stage of the request lifecycle. Together, these spans create a trace that shows exactly how long each operation takes and where delays or failures occur.

This made the backend much easier to debug during development.

Using SigNoz for Observability

Once OpenTelemetry was integrated, the traces were visualized using SigNoz.

SigNoz allowed me to observe:

Incoming API requests
Request latency
Individual spans within each trace
Failed requests
Backend execution flow

Whenever an evaluation request was made, I could inspect the trace and determine:

How much time was spent constructing the prompt.
How long the Groq API required to generate a response.
Whether JSON parsing succeeded.
Whether any exceptions occurred.

Instead of relying only on console logs, SigNoz provided a much clearer picture of the application's runtime behavior.

Challenges I Faced

This project involved several technical challenges.

One challenge was integrating AI-generated responses into a structured evaluation format. Since AI responses can vary, I had to ensure the backend consistently parsed the returned JSON before sending it to the frontend.

Another challenge involved adding OpenTelemetry instrumentation without affecting the application's normal workflow. Understanding spans, traces, and context propagation required experimentation and learning.

Deployment also introduced its own difficulties. Configuring environment variables, backend communication, and cloud deployment highlighted how observability tools become especially useful when debugging production environments.

Although these challenges required time to solve, they significantly improved my understanding of modern backend development.

What I Learned

Working on this project helped me understand that observability is much more than logging.

I learned:

How distributed tracing works.
How OpenTelemetry instruments backend applications.
How SigNoz visualizes traces and request execution.
Why monitoring AI-powered applications is important.
How observability simplifies debugging complex request flows.

Perhaps the biggest takeaway was realizing that identifying problems quickly is just as important as writing application features.

Future Improvements

There are several features I would like to add in future versions of InterviewIQ AI:

Voice-based interviews
Real-time conversational AI interviewer
Personalized interview recommendations
Performance analytics dashboard
Historical interview comparisons
Support for additional programming domains
Enhanced observability dashboards and alerts using SigNoz

These improvements would make the platform even more useful for interview preparation while expanding its monitoring capabilities.

Conclusion

Building InterviewIQ AI during the Agents of SigNoz Hackathon allowed me to combine artificial intelligence with modern observability practices.

The project demonstrated how OpenTelemetry and SigNoz can work together to provide visibility into backend operations, helping developers understand request execution, detect failures, and improve system reliability.

Beyond creating an AI interview platform, this experience strengthened my understanding of backend architecture, distributed tracing, and application monitoring. It showed me that observability is an essential part of building reliable software, especially as applications become more intelligent and distributed.

Thank you for reading!

My First Observability Journey with OpenTelemetry and SigNoz

Yamini Kotturi — Sun, 19 Jul 2026 06:53:56 +0000

Introduction

While building applications, I always focused on making my code work. But I wanted to understand what happens inside an application when something fails.

During the Agents of SigNoz Hackathon, I explored application observability by creating a Python application, instrumenting it using OpenTelemetry, and visualizing traces using SigNoz.

This blog explains my complete hands-on experience, including the setup process, debugging issues, and the final results.

Setting Up My Python Application

I created a simple Python application that simulates different application workflows:

User login processing
Fetching user data
Generating AI responses

The goal was to generate traces and observe the application behavior.

I configured OpenTelemetry to capture application execution details and send the trace data to SigNoz.

Debugging My First Issue

During the setup process, I encountered a Python syntax error.

The problem happened because an import statement was accidentally placed on the same line as another statement.

Error:

SyntaxError: invalid syntax

After fixing the code structure, the application started running successfully.

Sending Traces to SigNoz

After successful execution, my application started creating traces.

The terminal output showed different application steps:

User login processed
Fetching user data
Generating AI response
Done sending trace

These operations were captured as telemetry and sent to SigNoz.

Exploring Traces in SigNoz

The most exciting part was seeing my application's trace inside the SigNoz dashboard.

The trace view showed:

Trace ID
Span information
Execution duration
Error status
Events generated during execution

This helped me understand how a single request flows through different parts of an application.

Understanding Errors Through Traces

One interesting observation was that SigNoz captured application errors clearly.

For example, my trace showed:

Status Code: Error
Status Message: Exception: AI service timeout

Instead of only seeing a failed execution in the terminal, I could identify exactly which operation caused the problem.

This showed me how observability makes debugging easier.

Viewing Application Performance

The SigNoz service dashboard provided an overview of my application:

Application name
P99 latency
Error rate
Operations per second

This dashboard made it easy to understand the overall health and performance of the application at a glance.

Challenges I Faced

Configuration Errors

Connecting OpenTelemetry with SigNoz required understanding how telemetry moves between different components.

Python Application
↓
OpenTelemetry SDK
↓
Telemetry Collector
↓
SigNoz Dashboard

Debugging Trace Errors

Some traces contained errors like AI service timeout. Instead of ignoring them, I used SigNoz to analyze where the failure happened.

What I Learned

This project helped me understand:

✅ How OpenTelemetry collects telemetry data
✅ How traces represent application workflows
✅ How SigNoz helps debug applications
✅ Why observability is important for modern software systems

Before this experience, I mainly checked whether my application worked. Now I understand that knowing why something failed is equally important.

Conclusion

Building this project gave me practical exposure to observability concepts.

Using OpenTelemetry and SigNoz, I was able to monitor my Python application, view traces, analyze errors, and better understand application behavior.

This hackathon helped me move beyond simply writing code and start thinking about building reliable, observable, and maintainable applications.