DEV Community: Tanya Garg

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