DEV Community: Tanya Garg

Beyond Logs: Building Reliable AI Agents with SigNoz LLM Observability

Tanya Garg — Fri, 17 Jul 2026 15:56:38 +0000

How exploring SigNoz changed the way I think about monitoring AI applications.

Introduction

While preparing for the Agents of SigNoz Hackathon, I wanted to do more than just register and wait for the event to begin. Since the organizers encouraged participants to explore SigNoz before the hackathon, I decided to spend some time understanding what the platform actually offers and why observability has become such an important topic for modern AI applications.

Before this, my understanding of monitoring was fairly basic. I associated it with checking CPU usage, memory consumption, application logs, or server uptime. Those metrics are useful, but as I started learning more about AI systems, I realized they don't explain what is happening inside an AI workflow.

Think about an AI assistant that uses a Large Language Model (LLM). A single user request doesn't just go to the model and return a response. It may pass through authentication, a vector database, prompt construction, multiple API calls, external tools, memory retrieval, and finally the LLM before generating an answer. If something goes wrong in between, traditional monitoring often isn't enough to identify the exact cause.

This is where I discovered the concept of AI Observability, and that's what led me to SigNoz.

As I explored the platform, one thing immediately stood out—it isn't just another monitoring dashboard. SigNoz brings together logs, metrics, traces, dashboards, alerts, and AI observability into a single platform built on OpenTelemetry, making it much easier to understand what is happening inside an application.

In this blog, I'll share what I learned while exploring SigNoz, the features that impressed me the most, and why I believe observability is becoming an essential part of building reliable AI applications.

Why Traditional Monitoring Isn't Enough Anymore

Most developers, including me, usually begin debugging by checking logs or looking at CPU and memory graphs. That approach works reasonably well for traditional applications, but AI systems introduce an entirely different level of complexity.

Imagine asking an AI assistant:

"Summarize yesterday's meeting and create a follow-up email."

Behind the scenes, several operations happen almost instantly:

The request is authenticated.
Previous conversation history is retrieved.
Relevant documents are fetched from a vector database.
A prompt is generated.
The LLM processes the request.
External tools may be called.
The final response is formatted and returned.

If the response suddenly takes 12 seconds instead of 2, simply checking application logs doesn't immediately reveal the problem.

During my exploration of SigNoz, this became much clearer. Instead of showing only the final response time, observability helps break an entire request into smaller steps, making it easier to understand where time is being spent and which component is responsible for delays.

That shift in perspective was probably the biggest takeaway for me.

Understanding AI Observability

Before exploring SigNoz, I had heard the term observability many times but never really understood how different it was from monitoring.

The easiest way I can explain it now is this:

Monitoring tells you that something is wrong. Observability helps you understand why it went wrong.

For AI applications, that difference is extremely important.

Instead of tracking only infrastructure metrics, AI observability allows developers to understand what's happening throughout the complete lifecycle of an AI request.

Some examples include:

Model response latency
Prompt execution time
Token usage
Tool calls
API failures
Retrieval performance
Distributed traces
Error propagation

Seeing these capabilities helped me understand why observability has become such an important topic as AI applications continue to grow in complexity.

My First Impression of SigNoz

The feature that impressed me the most while exploring SigNoz was its ability to bring different types of telemetry into one place.

Rather than jumping between separate tools for logs, metrics, and traces, everything is available through a single interface.

For someone trying to understand how an application behaves internally, this makes debugging feel much more organized and intuitive.

Another thing I appreciated was that SigNoz is OpenTelemetry-native. Since OpenTelemetry has become the standard for collecting telemetry data, building on open standards instead of proprietary solutions makes the platform much more flexible for developers and organizations.

At this point, I started understanding that observability isn't just about fixing bugs—it's about building software with enough visibility that problems can be identified and solved before they affect users.

In the next section, I'll walk through the SigNoz platform, explain its core features, and share why Distributed Tracing became my favorite feature while exploring the platform.

Exploring SigNoz: Features That Stood Out

After understanding why observability matters, I wanted to see what SigNoz actually offers beyond the buzzwords.

As I explored the platform and its documentation, I realized that SigNoz isn't focused on just one aspect of monitoring. Instead, it combines everything needed to understand an application's health in a single place.

Some of the features that immediately caught my attention were:

Application Performance Monitoring (APM) for tracking application performance.
Distributed Tracing to follow requests across multiple services.
Centralized Log Management for debugging issues quickly.
Custom Dashboards for visualizing important metrics.
Real-time Alerts to detect problems before users report them.
LLM & AI Observability for monitoring AI-powered applications.

What impressed me the most was that these features are available within one platform rather than requiring multiple tools working together.

Understanding OpenTelemetry

While exploring SigNoz, I also learned why it emphasizes being OpenTelemetry-native.

Initially, I thought OpenTelemetry was simply another monitoring library. After reading more about it, I realized it has become the industry standard for collecting telemetry data.

Instead of using vendor-specific agents, developers instrument their applications once with OpenTelemetry and can send the collected data to compatible platforms like SigNoz.

This approach offers several benefits:

No vendor lock-in
Standardized telemetry collection
Support for multiple programming languages
Easier migration between observability platforms

For AI applications, this becomes even more valuable because a single request often travels through multiple services before generating a response.

OpenTelemetry captures each of these interactions, while SigNoz visualizes them in an easy-to-understand format.

Setting Up SigNoz

One thing I liked was that getting started with SigNoz is relatively straightforward.

The recommended approach is to run it locally using Docker.

The installation involves cloning the repository and starting the required services.

git clone https://github.com/SigNoz/signoz.git

cd signoz/deploy

docker compose up -d

After the services start, the dashboard becomes accessible through the browser.

Although the setup itself isn't complicated, I would still recommend checking the official documentation because it provides clear instructions for different operating systems and deployment options.

Figure 1: SigNoz Dashboard after completing the local setup.

The Feature I Found Most Interesting: Distributed Tracing

Among all the capabilities, Distributed Tracing was the feature that interested me the most.

When we build AI applications, a single request rarely consists of just one API call.

Instead, it usually looks something like this:

User Request
      │
      ▼
Authentication
      │
      ▼
Retrieve Context
      │
      ▼
Vector Database
      │
      ▼
     LLM
      │
      ▼
External Tool
      │
      ▼
Final Response

Without tracing, developers only know the total response time.

With distributed tracing, every step appears as an individual span.

For example, imagine an AI assistant takes 10 seconds to answer.

Tracing could reveal something like this:

Component	Time
Authentication	40 ms
Vector Search	320 ms
LLM Processing	6.2 s
External API	2.8 s
Response Formatting	120 ms

Instead of guessing where the slowdown happened, developers immediately know which component needs attention.

This made me appreciate why distributed tracing is considered one of the most powerful debugging tools for modern applications.

AI Observability: More Than Traditional Monitoring

Traditional monitoring tells us whether servers are healthy.

AI observability answers a different question:

"How well is my AI application actually performing?"

While exploring SigNoz, I found it interesting that AI-specific metrics can also be monitored.

These include:

Prompt execution time
LLM response latency
Token usage
Error rates
Tool invocation
Request success rate

These metrics become especially useful when building AI agents because performance depends on much more than server resources.

A perfectly healthy server can still produce a slow AI application if prompt execution, vector retrieval, or external APIs become bottlenecks.

Having visibility into these components makes troubleshooting significantly easier.

A Key Takeaway

The biggest lesson I learned while exploring SigNoz is that observability is not just about collecting logs.

It is about understanding the complete story behind every request.

Logs tell you what happened.

Metrics tell you how often it happens.

Distributed traces show exactly where it happened.

When all three are available together, debugging becomes much faster and more reliable.

That, in my opinion, is what makes SigNoz particularly valuable for developers building modern AI-powered applications.

In the final section, I'll share how LLM observability helps monitor token usage and costs, discuss dashboards and alerts, compare SigNoz with other observability platforms, and conclude with my overall thoughts after exploring the platform.

LLM Observability: A Feature Every AI Developer Should Understand

As AI applications continue to evolve, one thing became very clear to me while exploring SigNoz—monitoring an AI application is very different from monitoring a traditional web application.

For a normal application, checking CPU usage, memory utilization, request count, or response time is often enough.

But AI applications introduce completely new variables.

Questions like these become much more important:

Why is one prompt taking twice as long as another?
Which model is consuming the most tokens?
Which tool call failed?
Why did today's AI cost suddenly increase?
Which step in the workflow is creating the biggest delay?

These are questions that traditional monitoring tools simply weren't designed to answer.

This is where LLM Observability becomes incredibly valuable.

Instead of treating an LLM call as just another API request, SigNoz provides visibility into AI-specific metrics that actually matter.

Some examples include:

Prompt execution time
Response generation latency
Token usage
Model response time
Request failures
Tool invocation
End-to-end request traces

These insights make it much easier to understand how an AI application behaves in production.

Why Token Monitoring Matters

One topic I hadn't thought much about before exploring AI observability was token usage.

Every interaction with a language model consumes tokens.

A longer prompt or response means higher inference cost.

As an application scales, even small increases in token usage can have a noticeable impact on monthly expenses.

Instead of waiting for billing reports, developers can monitor token trends in real time and identify inefficient prompts or unusually expensive requests.

For teams deploying AI products in production, this kind of visibility can be just as important as monitoring latency.

Dashboards That Make Monitoring Easier

Another feature I liked was the flexibility of dashboards.

Instead of displaying only infrastructure metrics, dashboards can combine application health, traces, AI metrics, and performance graphs in one place.

For an AI application, a useful dashboard might include:

Average response latency
Request throughput
Error rate
Token consumption
Slowest endpoints
LLM latency
Tool execution time

Having all of these metrics together makes it much easier to understand the overall health of an application.

Figure 2: Dashboard showing request latency, throughput, traces, and application metrics.

Real-Time Alerts

Monitoring dashboards are helpful, but someone has to be looking at them.

This is where alerts become useful.

With SigNoz, developers can configure alerts for situations such as:

High response latency
Increased error rate
Unexpected token spikes
Database failures
Slow external APIs
Service downtime

Rather than discovering problems through user complaints, teams can identify issues much earlier and respond before they become major incidents.

Comparing SigNoz with Other Platforms

While researching observability tools, I also came across platforms like Datadog, New Relic, and Grafana.

Each has its own strengths, but one aspect that stood out about SigNoz is its focus on open standards.

Feature	SigNoz	Typical Proprietary Platform
Open Source	✅	Usually No
OpenTelemetry Native	✅	Partial
Self-hosting	✅	Limited
Unified Logs, Metrics & Traces	✅	✅
AI Observability	✅	Depends on Plan

For developers who value transparency, flexibility, and avoiding vendor lock-in, this is a significant advantage.

My Overall Takeaway

Exploring SigNoz changed how I think about monitoring modern software.

Earlier, I viewed monitoring as something you check only after an application breaks.

Now I understand that observability is about continuously understanding how an application behaves and why something goes wrong.

The feature I found most useful was Distributed Tracing, because it makes debugging much more visual and intuitive.

I also found AI observability particularly interesting since AI applications introduce challenges—like token usage, prompt performance, and model latency—that traditional monitoring tools were never designed to solve.

Although I explored SigNoz as part of preparing for the Agents of SigNoz Hackathon, it gave me a much better understanding of why observability is becoming an essential part of building production-ready AI applications.

Conclusion

Artificial Intelligence is changing how we build software, but it also introduces new debugging and monitoring challenges.

After spending time exploring SigNoz, I now have a much clearer understanding of why observability is more than just logs and dashboards. Being able to view metrics, traces, logs, alerts, and AI telemetry together provides a much deeper understanding of application behavior.

If you're planning to build AI agents, chatbots, or any LLM-powered application, I believe learning observability early is just as important as learning the AI frameworks themselves.

For me, exploring SigNoz wasn't just preparation for a hackathon—it was an opportunity to better understand how production AI systems are monitored, optimized, and maintained.

I'm excited to apply these learnings while building projects during the Agents of SigNoz Hackathon, and I hope this article helps other developers who are beginning their own observability journey.

References

SigNoz Documentation
SigNoz GitHub Repository
OpenTelemetry Documentation
CNCF OpenTelemetry Project

Thanks for reading! If you're participating in the Agents of SigNoz Hackathon, I highly recommend exploring SigNoz yourself. Even a short hands-on session provides a much better understanding of observability than reading documentation alone, and it's a great way to prepare before building AI applications in the hackathon.

🚀 Building Two AI-Powered Solutions at HACKHAZARDS '26: VeritasFlow & PermitFlow

Tanya Garg — Wed, 15 Jul 2026 14:43:18 +0000

🚀 Building Two AI-Powered Solutions at HACKHAZARDS '26: VeritasFlow & PermitFlow

How our team built two AI-powered solutions—VeritasFlow and PermitFlow—during one of the world's largest community-driven hackathons.

Introduction

Innovation begins with identifying real-world problems and building technology that creates meaningful impact.

That belief guided our team throughout HACKHAZARDS '26, a global community-driven buildathon organized by NAMESPACE. Unlike traditional 24- or 48-hour hackathons, HACKHAZARDS gave participants nearly two months to research, design, develop, and refine production-ready solutions instead of rushed prototypes.

With over 30,000 participants from more than 75 countries, the event brought together developers, designers, and innovators to solve meaningful challenges using modern technologies.

As a team, we challenged ourselves to build solutions for two completely different problem domains.

One focused on improving digital wellbeing and responsible information consumption.

The other focused on transforming construction permit approvals through AI-powered compliance automation.

That journey resulted in two projects:

🧠 VeritasFlow – AI-Powered Information Diet Coach
🏗️ PermitFlow – The Construction Compliance Autopilot

Although they solve different problems, both projects share the same vision:

Building AI that solves real-world problems, not just showcases technology.

🧠 Project 1: VeritasFlow – AI-Powered Information Diet Coach

The Problem

The internet gives us unlimited access to information, but not all information is beneficial.

Every day people are exposed to endless news articles, social media feeds, videos, and recommendations that often prioritize engagement over quality. This results in information overload, echo chambers, misinformation, and unhealthy digital habits.

We wanted to build a platform that helps users become more mindful of what they consume online.

Our Solution

VeritasFlow is an AI-powered Information Diet Coach that analyzes users' content consumption patterns and recommends healthier, more balanced, and more informative content.

Rather than maximizing screen time, VeritasFlow focuses on improving digital wellbeing through intelligent recommendations and personalized insights.

Users can understand how they consume information and gradually build healthier digital habits.

Key Features

AI-powered content analysis
Sentiment analysis
Personalized recommendations
Article summarization
Digital wellbeing dashboard
Information diversity score
Reading insights
AI-powered recommendation engine

Technology Stack

React
FastAPI
Python
MongoDB
Natural Language Processing (NLP)
Sentiment Analysis
Recommendation Engine

Implementation

The platform processes user content using NLP techniques to identify topics, sentiment, and reading patterns. Based on this analysis, the recommendation engine suggests educational and balanced content while providing personalized insights into users' digital habits.

Our goal was not to encourage users to spend more time online but to help them spend their time more meaningfully.

🏗️ Project 2: PermitFlow – The Construction Compliance Autopilot

The Problem

Construction permits remain one of the biggest bottlenecks in urban development.

Contractors often spend weeks navigating complicated zoning regulations, submitting repetitive paperwork, correcting applications, and waiting for approvals.

Even a single missing document can delay an entire construction project.

We wanted to simplify this complex process using Artificial Intelligence.

Our Solution

PermitFlow is an AI-powered construction compliance platform that streamlines the permit approval workflow for contractors, architects, municipal officers, and administrators.

Users upload project documents, and the platform automatically analyzes compliance requirements, detects missing information, assists with documentation, and guides applicants throughout the approval process.

Key Features

AI Blueprint Analysis
OCR-based document extraction
Compliance Gap Detection
Government Form Autofill
Permit Status Tracking
Municipal Officer Dashboard
Admin Analytics Dashboard
AI Compliance Assistant
Multilingual Support

Technology Stack

React
FastAPI
Python
MongoDB
OCR
JWT Authentication
Sarvam AI

How We Used Sarvam AI

PermitFlow was also built for the Sarvam AI Track, where Sarvam AI became a key part of our solution.

We integrated Sarvam AI to:

Build a multilingual AI compliance assistant.
Answer user queries related to zoning rules, FAR limits, setbacks, Fire NOCs, and municipal regulations.
Translate compliance guidance into multiple Indian languages.
Enable voice-based interactions for easier accessibility.
Simplify complex legal and technical regulations into easy-to-understand explanations.

By integrating Sarvam AI, PermitFlow became more accessible, user-friendly, and practical for contractors, architects, and government officials across India.

Challenges We Faced

Although both projects belonged to different industries, they presented equally interesting engineering challenges.

For VeritasFlow, designing recommendations that promote healthier information consumption rather than maximizing engagement required careful planning and experimentation.

For PermitFlow, understanding complex construction regulations and transforming them into a simple AI-assisted workflow required thoughtful product design and user-centric development.

Throughout the hackathon, we continuously refined our UI, backend architecture, and AI workflows to create solutions that were both practical and intuitive.

What We Learned

HACKHAZARDS '26 taught us that successful AI applications begin with understanding real user problems.

Beyond writing code, we learned the importance of product thinking, collaboration, user experience, and responsible AI implementation.

Working on two completely different projects also strengthened our understanding of full-stack development, document intelligence, recommendation systems, workflow automation, and AI integration.

Looking Ahead

Both projects have exciting possibilities for future development.

VeritasFlow

Browser Extension
Fake News Detection
AI Wellness Score
Social Media Feed Analysis
Mobile Application
Advanced Recommendation Models

PermitFlow

GIS-based Zoning Verification
BIM/CAD Blueprint Support
Real-time Municipal API Integration
Predictive Approval Analytics
Digital Signature Support
Inspection Scheduling
Mobile App for Field Officers

Final Thoughts

HACKHAZARDS '26 was much more than a hackathon—it was an incredible learning journey.

It gave us the opportunity to transform ideas into working products, collaborate as a team, and explore how AI can solve meaningful problems across entirely different industries.

From promoting healthier digital habits with VeritasFlow to simplifying construction compliance through PermitFlow and Sarvam AI, this journey reinforced one important belief:

Technology creates the greatest impact when it solves real problems for real people.

A heartfelt thank you to NAMESPACE, the mentors, organizers, and partner communities for creating such an amazing platform for builders around the world.

We are excited to continue improving both projects beyond the hackathon and turn them into solutions that create real-world impact.

👥 Team

Prerna — Team Lead
Tanya Garg — AI & Backend Developer
Kritika Maurya — Frontend & Design Lead

Thanks for reading! If you'd like to connect, share feedback, or discuss these projects, feel free to reach out. Happy building! 🚀

Building DetectiveAI: Giving Crime Investigation an AI That Never Forgets with Cognee

Tanya Garg — Sun, 05 Jul 2026 17:47:08 +0000

Introduction

One of the biggest limitations of modern AI assistants is memory. Every new conversation starts almost from scratch, making it difficult to work on long-running investigations or complex cases.

For my hackathon project, I wanted to solve exactly this problem.

I built DetectiveAI, an AI-powered crime investigation assistant that uses Cognee Cloud as its persistent memory layer. Instead of forgetting evidence after every session, DetectiveAI stores, organizes, and recalls investigation data whenever it is needed.

The Problem

Imagine a detective investigating a case over several days.

New evidence keeps arriving:

Witness statements
CCTV footage
Crime scene observations
Timelines
Suspect information

Traditional AI can summarize information, but it doesn't naturally remember and connect all of these details across sessions.

This is where persistent memory becomes essential.

My Solution

DetectiveAI combines a simple investigation workflow with Cognee Cloud.

The investigator can:

Create a crime case
Add evidence
Store investigation details
Search previous information
Ask natural language questions
Generate investigation summaries

Because the information is stored inside Cognee, the AI can retrieve relevant context instead of depending only on the current prompt.

How Cognee Powers DetectiveAI

Cognee acts as the memory layer for my application.

Each investigation is stored as structured knowledge rather than temporary chat history.

When the investigator asks questions like:

Who is the suspect?
Summarize this investigation.
What relationships exist between the evidence?
Explain the timeline.

Cognee retrieves the most relevant information from the stored investigation memory.

Features

Create Case

Start a new investigation with:

Case name
Location
Date
Officer name
Initial description

Add Evidence

Store investigation evidence including:

Witness statements
CCTV observations
Timeline events
Physical evidence

Investigation Chat

Interact with the investigation using natural language instead of manually searching documents.

Persistent Memory

Unlike traditional AI assistants, DetectiveAI remembers previously stored information and can reuse it across future sessions.

Investigation Reports

Generate structured summaries of the investigation for quick review.

Tech Stack

Cognee Cloud
Python
AI Language Model
Modern Web Interface

What I Learned

This project taught me that AI memory is much more than saving chat history.

Persistent memory allows AI systems to continuously build knowledge, connect related information, and provide more reliable answers over time.

Cognee made it easy to explore this concept while building a practical real-world application.

Future Improvements

Multi-case investigations
Image and PDF evidence analysis
Voice-based investigation assistant
Collaborative investigations for multiple officers
Automatic contradiction detection
Risk scoring for suspects

Conclusion

DetectiveAI demonstrates how persistent memory can transform AI assistants from simple chatbots into long-term intelligent investigation systems.

With Cognee Cloud, our AI doesn't just answer questions—it remembers the investigation.

CrisisIQ – AI-Powered Business Risk Intelligence using Gemma 4

Tanya Garg — Fri, 22 May 2026 18:01:53 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

CrisisIQ – AI-Powered Crisis Intelligence & Business Risk Analysis Dashboard

What I Built

CrisisIQ is an AI-powered business intelligence dashboard that analyzes how global crises impact companies, industries, and supply chains in real time.

Modern companies operate in highly interconnected ecosystems where geopolitical conflicts, cyberattacks, economic instability, sanctions, natural disasters, and trade disruptions can rapidly affect operations worldwide. CrisisIQ helps users understand these impacts using AI-driven analysis and contextual reasoning.

The platform allows users to:

analyze company exposure during crises
understand operational and financial risks
simulate business disruption scenarios
generate AI-powered mitigation strategies
summarize complex global events into actionable insights

Instead of manually reading lengthy reports and news articles, users receive structured AI-generated intelligence instantly.

Demo

Features Demonstrated

Company risk analysis dashboard
Crisis impact summarization
AI-generated mitigation strategies
Scenario simulation
Industry-wise risk comparison
Supply chain disruption analysis

Demo Video

https://drive.google.com/file/d/1kMt-lclhDu2YvFDQi1mgjPbBoagkEouq/view?usp=drive_link

Live Project

https://crisisiq-ai-business-risk-intelligence-using-gemma-4-edaputmky.streamlit.app/

Screenshots

Code

GitHub Repository

https://github.com/Tanya-garg10/CrisisIQ-AI-Business-Risk-Intelligence-using-Gemma-4.git

Tech Stack

Python
Streamlit
Gemma 4
Pandas
Plotly
OpenRouter / Google AI Studio API
News APIs

How I Used Gemma 4

Gemma 4 powers the core reasoning engine of CrisisIQ.

The application collects company data, industry context, and crisis-related information, then uses Gemma 4 to generate intelligent business impact analysis.

Model Used

Gemma 4 31B Dense

Why I Chose the 31B Dense Model

I intentionally selected the 31B Dense model because the project depends heavily on:

long-context understanding
analytical reasoning
structured business analysis
multi-factor risk interpretation

The larger context window allowed the model to process:

lengthy crisis reports
multiple company profiles
supply chain dependencies
geopolitical developments

This made the 31B Dense model the ideal choice for generating detailed and reliable business intelligence insights.

How Gemma 4 Powers the System

Gemma 4 analyzes:

crisis events
company operations
industry dependencies
supply chain vulnerabilities
financial exposure

The model then generates:

risk assessments
operational impact summaries
mitigation recommendations
scenario-based predictions
executive-level insights

Example Output

“The ongoing geopolitical conflict may significantly disrupt semiconductor supply chains affecting manufacturing timelines and increasing operational costs for automotive companies dependent on Asian suppliers.”

The system transforms raw crisis information into understandable strategic intelligence.

Key Features

AI Risk Scoring

Generates dynamic company risk scores based on current events.

Crisis Summarization

Converts complex news and reports into concise business insights.

Scenario Simulation

Allows users to test hypothetical crisis situations and predict business outcomes.

Supply Chain Intelligence

Identifies vulnerable operational dependencies and potential disruption points.

Executive Insights

Produces human-readable strategic recommendations for decision-making.

Challenges I Faced

One of the main challenges was designing prompts that produced structured, analytical responses instead of generic summaries.

Another challenge was handling large volumes of contextual information while maintaining coherent reasoning and fast response times.

Balancing accuracy, readability, and practical usefulness required significant prompt engineering and response optimization.

What I Learned

Through this project, I gained deeper experience in:

AI-powered reasoning systems
long-context prompt engineering
business intelligence workflows
risk analysis pipelines
dashboard development
integrating LLMs into analytical applications

I also learned how powerful open models like Gemma 4 can be for enterprise-style AI applications.

Future Improvements

Planned future enhancements include:

real-time live news integration
predictive trend forecasting
interactive crisis maps
AI-generated financial impact estimation
multilingual analysis support
collaborative enterprise dashboards

Final Thoughts

CrisisIQ demonstrates how AI can transform overwhelming global information into actionable strategic intelligence.

By combining real-world crisis data with the reasoning capabilities of Gemma 4, the platform helps businesses better understand risks, prepare for disruptions, and make informed decisions faster.

This project highlights the growing potential of open AI models in enterprise intelligence and decision-support systems.

Building a Smart Environmental Monitoring System with Google Cloud (Inspired by NEXT ‘26)

Tanya Garg — Thu, 23 Apr 2026 05:13:43 +0000

Building a Smart Environmental Monitoring System with Google Cloud (Inspired by NEXT ‘26)

This is a submission for the Google Cloud NEXT Writing Challenge

🌍 Why Google Cloud NEXT ‘26 Caught My Attention

Every year, Google Cloud NEXT brings new ideas, but this time what stood out to me was the strong push toward real-time data processing, AI integration, and scalable cloud-native systems.

As someone working on IoT + web-based systems, I was especially interested in how cloud tools can handle live sensor data efficiently and make it useful.

💡 The Idea: Smart Environmental Monitoring System

Inspired by the announcements around cloud scalability and developer tools, I decided to explore a simple but practical use case:

A system that monitors temperature, CO₂ levels, and soil moisture in real time.

This kind of system can be useful for:

Smart agriculture 🌱
Indoor air quality monitoring 🏠
Climate-aware applications 🌍

🛠️ Tech Stack I Used

Raspberry Pi → Collect sensor data
Django (Backend) → Handle APIs & data processing
React.js (Frontend) → Display real-time dashboard
HTTP Protocol → Send live sensor data
Google Cloud (Conceptual Integration):
- Cloud Run / App Engine (deployment ideas)
- Cloud Storage / Firestore (data handling)
- AI/ML possibilities for predictions

⚙️ How It Works

Sensors connected to Raspberry Pi collect data
Data is sent via HTTP to a Django backend
Backend processes and stores the data
React dashboard displays it in real time

🔍 What I Learned from NEXT ‘26

1. Cloud Makes Real-Time Systems Scalable

Before cloud integration, systems like this are limited locally.
With Google Cloud, this can scale to:

Thousands of devices
Multiple locations
Real-time analytics

2. AI Integration is the Next Step

The real power is not just collecting data, but:

Predicting trends
Detecting anomalies
Automating alerts

For example:

Predict soil dryness before it happens
Alert when CO₂ levels become unsafe

3. Developer Experience is Improving

One key takeaway from NEXT ‘26 is how tools are becoming:

Easier to deploy
More integrated
Faster to build with

This reduces the gap between idea → prototype → production.

🤔 My Honest Take

While Google Cloud offers powerful tools, beginners might still face:

Initial setup complexity
Understanding pricing
Choosing the right service

However, once you get past that, the ecosystem is incredibly powerful.

🚀 What I’d Do Next

If I extend this project using Google Cloud:

Deploy backend on Cloud Run
Store real-time data in Firestore
Use AI models for prediction
Add alerts using cloud functions

📌 Final Thoughts

Google Cloud NEXT ‘26 reinforced one thing for me:

The future is not just about building apps — it’s about building intelligent, scalable systems.

Even a simple IoT project can become powerful when combined with cloud + AI.

💬 What About You?

Did you explore anything from Google Cloud NEXT ‘26?
What feature excited you the most?

Let’s discuss 👇

🤡 I Built an AI That Gives the Worst Advice Ever (On Purpose)

Tanya Garg — Fri, 10 Apr 2026 10:37:27 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built an AI-powered web app called “Worst Advisor Ever” — an application that gives you the most terrible, chaotic, and absolutely useless advice possible.

Instead of helping you make better decisions, this app confidently suggests the worst possible choices 😭

Examples:

Input: “Should I study for my exam?” Output: “No. Knowledge is temporary, vibes are forever.”
Input: “Should I save money?” Output: “Invest everything in imaginary stocks.”

The goal? Make users laugh, question life choices, and regret asking for advice in the first place.

Demo

👉 Live Demo: https://hdtkpyfikfrfaoeteddsai.streamlit.app/
👉 Video Demo: https://youtu.be/3QxcMWa5EZc

Code

👉 GitHub Repository: https://github.com/Tanya-garg10/Worst-Advisor-Ever-.git

How I Built It

I built this project using:

Frontend: React.js (for an interactive UI)
Backend: Django / Node.js
AI Integration: Prompt-based AI that is intentionally designed to generate the worst advice possible
Styling: CSS (with a playful and chaotic UI to match the theme)

The core idea was prompt engineering:
Instead of optimizing for correctness, I optimized for maximum nonsense and humor.

Prize Category

🏆 Best Google AI Usage

I used AI creatively and unconventionally — not to solve problems, but to make them worse 😄

The system prompt was designed to:

Always give bad advice
Sound confident (even when completely wrong)
Be funny and unpredictable

This flips the usual use of AI on its head, making it intentionally useless but highly entertaining.

Final Thoughts

Building something useless was surprisingly refreshing.

In a world where everything needs to be productive, optimized, and scalable, this project celebrates chaos, humor, and creativity.

Sometimes, the best ideas are the ones that make absolutely no sense.

⚠️ Disclaimer: Please do NOT follow any advice from this app. Seriously.

Building TeamMind AI: A Project Manager That Learns From the Past

Tanya Garg — Mon, 23 Mar 2026 06:28:39 +0000

Hindsight Made Our Project Manager Remember

Our first assignment logic was embarrassingly simple: match skills, count workload, pick a name.

It looked fine — until we realized it treated a reliable finisher and a repeat blocker exactly the same.

That’s when I built TeamMind AI — a project manager that doesn’t just assign tasks, but remembers how your team actually works.

🚨 The Problem With Generic Task Assignment

Most project management systems (and even AI tools) assign work based on:

skills
availability
workload

On paper, that makes sense.

But in reality, it ignores something critical:

👉 delivery behavior

Who consistently finishes tasks?
Who gets blocked repeatedly?
What decisions were already made in meetings?

Without this context, every sprint starts like the system has amnesia.

💡 What I Built: TeamMind AI

TeamMind AI is a Streamlit-based application that combines:

Team member tracking
Task assignment
Meeting notes
AI-based recommendations

But the key difference is:

👉 It uses a memory layer powered by Hindsight to influence decisions.

Instead of just generating answers, it recalls past events and uses them to explain recommendations.

🧠 Adding Memory With Hindsight

I integrated the Hindsight system as a memory backend.

This allowed us to store structured events like:

team members and their skills
completed tasks
delayed or blocked work
meeting decisions
recurring issues

Each interaction is stored as a memory event, which can later be retrieved when assigning new tasks.

⚙️ How It Works (Simplified)

Step 1: Store memory

Whenever something happens:

task completed
blocker reported
meeting note added

We send it to the memory system.

Step 2: Recall memory

When assigning a new task:

relevant past events are retrieved
patterns are analyzed
context is added to the recommendation

Step 3: Generate recommendation

Now the system doesn’t just say:

“Assign to Aisha”

It says:

“Assign to Aisha because she completed similar Streamlit work and has no blocker history, while others faced issues in related tasks.”

🔄 Before vs After Memory

❌ Before (Generic Assignment)

Based on skills + workload
No historical awareness
No explanation

Example:
Aisha is selected simply because she knows Streamlit.

✅ After (Memory-Based Assignment)

Uses past performance
Considers blockers and delays
Includes meeting decisions
Provides explainable output

Example:
Aisha is selected because:

she completed similar dashboard tasks
she consistently delivers on time
other teammates had blocker history in similar work

👉 This is not just smarter — it’s trustworthy.

👀 Making Memory Visible

One key lesson I learned:

Memory is useless if users can’t see it working.

So instead of hiding it, we exposed:

recalled memory context
evidence behind recommendations
comparison between generic and memory-based suggestions

This makes the system:

transparent
debuggable
believable

TeamMind AI interface showing task and team management

Comparison between generic and memory-based task assignment

⚠️ Challenges I Faced

This wasn’t just a UI problem.

The real challenges were:

Setting up the memory API
Handling async memory indexing
Ensuring recall returns useful context
Dealing with deployment limitations
Debugging when memory wasn’t immediately available

📌 Key Lessons

Skills alone are not enough
Memory should influence decisions, not just store data
Explainability builds trust
Visibility of memory is critical
Past behavior is the best predictor of future performance

🚀 Final Thought

Most project management tools track what happened.

TeamMind AI goes one step further:

👉 It remembers what happened — and uses that memory to make better decisions.

🔗 Useful Links

💬 Closing

If you’re building AI systems:

Don’t just make them smarter.
Make them remember.

Repo: https://github.com/Tanya-garg10/TeamMind-AI

AI Workflow SuperAgent: Turning Notion Into an Autonomous Productivity OS

Tanya Garg — Sun, 15 Mar 2026 18:15:44 +0000

What I Built

I built AI Workflow SuperAgent, an AI-powered productivity system that transforms a Notion workspace into an intelligent task management assistant.

Many people store tasks, ideas, and notes in productivity tools but still struggle to prioritize and organize their workflow effectively. This project solves that problem by combining AI with Notion MCP to automatically analyze tasks and generate actionable plans.

The system reads tasks from a Notion database and uses an AI model to:

Analyze task priorities
Break large tasks into smaller subtasks
Generate a daily productivity plan
Provide insights through a dashboard

Instead of manually planning everything, users can simply write their tasks inside Notion and the AI system converts them into a structured workflow.

For example, if a user adds tasks like:

Build AI dashboard
Apply for internships
Finish hackathon submission

The AI system analyzes them and produces:

Priority ranking
Subtasks for each task
Daily focus recommendations

This creates a human-in-the-loop AI productivity workflow, where users control their workspace while AI helps optimize their productivity.

Video Demo

In the demo video, I show how the system works step-by-step:

Creating tasks in a Notion database
Running the AI workflow system
AI analyzing tasks and generating priorities
Viewing tasks and insights in a Streamlit dashboard

The demo highlights how AI can transform a simple task list into an intelligent workflow assistant.

https://drive.google.com/file/d/1JzZRo3JzyK1jyC_N8tWF7sRNeH-IODKW/view?usp=drive_link

Show us the Code

GitHub Repository:

https://github.com/Tanya-garg10/ai-workflow-superagent.git

Project structure:

ai-notion-superagent
│
├── backend
│   ├── main.py
│   ├── ai_processor.py
│   ├── workflow_engine.py
│
├── frontend
│   └── dashboard.py
│
├── requirements.txt
└── README.md

The backend is built using FastAPI, while the frontend dashboard is built using Streamlit.

How I Used Notion MCP

Notion MCP is the core component that connects the AI system with the Notion workspace.

The workflow works as follows:

Tasks are stored in a Notion database.
The AI system accesses the workspace through Notion MCP.
Tasks are extracted and processed using an AI model.
The AI analyzes task importance, deadlines, and dependencies.
The system generates structured outputs such as:

priority rankings
task breakdowns
productivity summaries

By using Notion MCP, the AI can interact with Notion as a structured productivity environment instead of just plain text data. This enables intelligent automation and real workflow management.

Breaking the Glass Ceiling in Tech – Frontend Art for Gender Equity

Tanya Garg — Wed, 11 Mar 2026 14:47:21 +0000

This is a submission for the 2026 WeCoded Challenge: Frontend Art

Show us your Art

My artwork represents the idea of breaking the glass ceiling in technology.

In this project, I created a small interactive frontend design using HTML, CSS, and JavaScript. The visual concept shows a glass barrier that shatters, symbolizing the breaking of limitations that many women and underrepresented voices face in the tech industry.

As the glass breaks, technology icons and coding elements appear, representing growth, opportunity, and innovation when diversity is embraced.

This artwork highlights a simple message:

Talent has no gender. Innovation belongs to everyone.

🔗 Live Demo: https://tanya-garg10.github.io/wecoded-frontend-art/

Inspiration

My inspiration comes from the increasing presence of women and diverse communities in technology. Even though the tech industry has historically had barriers, many developers today are challenging those limitations and creating space for inclusion.

The "glass ceiling" is a powerful symbol of invisible barriers that prevent equal opportunities. By visually breaking that barrier in this artwork, I wanted to represent empowerment, resilience, and progress.

Technology grows stronger when people from different backgrounds contribute their ideas and perspectives.

My Code

This project was built using simple frontend technologies:

HTML for structure
CSS for styling and animations
JavaScript for interaction and visual effects

The animations and design aim to create a symbolic experience that represents gender equity in tech through creative frontend expression.

🔗 GitHub Repository: https://github.com/Tanya-garg10/wecoded-frontend-art.git

Thank you to the DEV community for creating a space where developers can share their stories, creativity, and ideas. 💜

“From No Portfolio to a Live Developer Portfolio Using Kuberns AI”

Tanya Garg — Thu, 05 Mar 2026 05:19:57 +0000

🚀 From No Portfolio to a Live Developer Portfolio Using Kuberns AI

Introduction

As developers, we often build multiple projects but forget to showcase them properly. A developer portfolio is one of the best ways to present your skills, projects, and achievements in one place.

Recently, while participating in the Kuberns AI Portfolio Hackathon 2026, I decided to finally create and deploy my portfolio.

Interestingly, I did not have a portfolio website before this challenge. So I started from scratch — built my portfolio and deployed it live using Kuberns AI, an AI-powered deployment platform that simplifies the entire hosting process.

Building My Portfolio

The first step was to design a portfolio that could clearly represent my work and technical journey.

My portfolio includes sections such as:

👩‍💻 About Me
🛠 Technical Skills
🚀 Projects
🏆 Achievements
📬 Contact Information

Through this portfolio, I showcase projects related to AI systems, machine learning, data intelligence platforms, and full-stack web applications.

🌐 Live Portfolio

👉 https://tanya-garg-portfolio-main-727ec31.kuberns.cloud/

Deploying the Portfolio with Kuberns AI

After building the portfolio, the next step was deployment.

Instead of going through complex hosting configurations, I used Kuberns, which provides AI-powered one-click deployment.

The deployment process was very simple:

1️⃣ Connect the project repository
2️⃣ Click deploy
3️⃣ Kuberns automatically handles build and hosting

Within a few minutes, my portfolio was live and publicly accessible.

Deployment Proof

Below is the screenshot of my Kuberns dashboard, showing the successful deployment of my portfolio.

Why Kuberns AI Is Useful

What stood out to me was how simple and fast the deployment experience was.

Some key advantages:

⚡ One-click AI deployment
🚀 Fast build and hosting process
🧑‍💻 Developer-friendly workflow
🌐 Instant public access to deployed projects

For developers who want to deploy projects quickly without dealing with complicated infrastructure, Kuberns makes the process extremely smooth.

Final Thoughts

Participating in the Kuberns AI Portfolio Hackathon 2026 motivated me to finally build my portfolio and deploy it live.

It was a great experience turning something that didn’t exist before into a live developer portfolio within a short time.

If you’re a developer who hasn’t created a portfolio yet, this challenge is a great reminder that showcasing your work matters — and platforms like Kuberns AI make deployment incredibly easy.

Learn more about Kuberns here:
👉 https://kuberns.com