DEV Community: Shirisha Uppoju

How to Turn Any SaaS Into a Telegram Bot in 30 Minutes Using OpenClaw

Shirisha Uppoju — Sun, 19 Apr 2026 21:52:15 +0000

This is a submission for the DEV OpenClaw Challenge 2026: Wealth of Knowledge

The Problem Every SaaS Founder Has

You built a beautiful web app. Users love it. But friction is real: they have to open the browser, navigate to your site, log in, and then use your product.

What if they could just message you on Telegram?

Last week I gave my meal planning SaaS MealAI a Telegram interface using OpenClaw. It took 30 minutes. No webhook hosting. No bot framework to learn. No custom API glue code.

Here is exactly how I did it, and how you can do the same for any SaaS.

What You Will Build

A Telegram bot that:

Talks in your product's voice (not generic ChatGPT)
Has your product's domain expertise baked in
Responds with branded formatting (emojis, bold, structure)
Can be extended to call your real APIs

Time: 30 minutes
Cost: Free (Docker + OpenAI API credits)
Prerequisites: Basic Docker knowledge, an OpenAI or Anthropic API key

Why OpenClaw?

Before OpenClaw, building a Telegram AI bot meant:

A Node.js backend with grammY or telegraf
A hosted webhook endpoint
Custom prompt management
Session and memory handling
Rate limiting logic
Deployment pipeline

OpenClaw is an MIT licensed AI agent runtime that handles all of this in one binary. It supports 25 plus messaging platforms (Telegram, WhatsApp, Discord, Slack, Signal, iMessage, and more). Your agent works on any of them without code changes.

Think of it as the WordPress of AI agents for messaging.

Step 1: Install Docker (2 min)

On macOS, I recommend OrbStack. It is lighter than Docker Desktop.

brew install --cask orbstack
open -a OrbStack

On Linux or Windows, use Docker Desktop.
Verify it works:

bash
docker --version

Step 2: Pull OpenClaw (2 min)

Create a working directory:

mkdir mealai-concierge && cd mealai-concierge

Pull the pre built image:

bash
docker pull ghcr.io/openclaw/openclaw:latest

Step 3: Create a Telegram Bot (3 min)

Open Telegram, search for @botfather
Send /newbot
Choose a name and username (must end in _bot)
Copy the HTTP API token Your bot URL will be t.me/your_bot_username. ## Step 4: Configure OpenClaw (5 min) Create a docker-compose.yml:

services:
openclaw-gateway:
image: ghcr.io/openclaw/openclaw:latest
environment:
HOME: /home/node
TZ: UTC
volumes:
- ./openclaw-config:/home/node/.openclaw
- ./openclaw-workspace:/home/node/.openclaw/workspace
ports:
- "18789:18789"
- "18790:18790"
init: true
restart: unless-stopped
command:
- node
- dist/index.js
- gateway
- --bind
- lan
- --port
- "18789"

Create openclaw-config/openclaw.json:

json
{
"gateway": {
"mode": "local"
},
"channels": {
"telegram": {
"enabled": true,
"botToken": "YOUR_TELEGRAM_BOT_TOKEN_HERE",
"dmPolicy": "open",
"allowFrom": ["*"]
}
},
"agents": {
"defaults": {
"model": "openai/gpt-4o-mini"
}
}
}

Create openclaw-config/agents/main/agent/auth-profiles.json:

{
"version": 1,
"profiles": {
"openai:default": {
"type": "api_key",
"provider": "openai",
"key": "sk-YOUR_OPENAI_KEY_HERE"
}
}
}

## Step 5: The Secret Sauce, SOUL.md (10 min)
This is where a generic chatbot transforms into your product's voice.
Create openclaw-workspace/SOUL.md:

markdown
SOUL.md MealAI Concierge
You are MealAI Concierge, a friendly AI meal planning assistant.

Your Role
Help busy people answer: "What's for dinner?" and plan their week.

Personality
Warm, conversational, concise
Opinionated about food (no hedging)
Practical over perfect
Real people eat real food
What You Do Best
Suggest meal plans (day or week)
Build grocery lists grouped by store section
Adapt to preferences (vegetarian, budget, high protein, picky kids)
Explain nutrition simply
Recipe quick hits, ingredients plus 5 steps
Response Format
Bold meal names
Sparse emojis (salad, pasta, breakfast)
Under 200 words unless asked for detail
Rules
Never open with "Great question!", just answer
Redirect off topic: "That is outside my kitchen!"
Always end with a follow up: "Want the grocery list?"
Mention usemealai.com for full features
Why SOUL.md is powerful:
OpenClaw injects this at the system prompt level on every conversation. The model always sees these instructions before user messages. This is why the persona stays consistent. It is not fine tuning, it is prompt engineering at the right architectural layer.

Step 6: Start It Up (1 min)

docker compose up -d

Check the logs:

bash
docker compose logs -f openclaw-gateway

You should see:
[telegram] [default] starting provider (@YourBotName_bot)

Step 7: Test It (2 min)

Open Telegram, find your bot, and say:

"Hi, who are you?"
"What is for dinner tonight?"
"I am vegetarian, plan my week" You will see it responds as your product, not as ChatGPT. ## The Magic Revealed Here is what OpenClaw is doing under the hood: User message (Telegram) -> OpenClaw Gateway (long polling Telegram API) -> System prompt assembly:

Your SOUL.md (persona)
Your IDENTITY.md (name, vibe)
Conversation history
->
Routed to OpenAI gpt-4o-mini
->
Response sent back via Telegram API
You never wrote a single line of bot framework code. The entire integration layer is one SOUL.md file.

Next Level Moves

Once the basics work, you can layer on:

Add custom skills (call your real API)

Create an OpenClaw skill that fetches real meal plans from your SaaS database. OpenClaw has a plugin SDK that lets the agent decide when to call your API based on the user's message.

Multi channel in one line

Want the same bot on WhatsApp, Discord, or Signal? Add another entry to channels:


json
"channels": {
"telegram": { "enabled": true, "botToken": "..." },
"discord": { "enabled": true, "botToken": "..." },
"whatsapp": { "enabled": true }
}

One codebase. Every platform.
### Persistent memory
The openclaw-workspace directory is your bot's long term memory. Drop markdown files with user preferences, FAQs, or product knowledge. OpenClaw pulls from them contextually.
### Control UI dashboard
OpenClaw ships with a web dashboard at http://localhost:18789 where you can:
* See every conversation live
* Monitor API costs
* Debug prompts
* Switch models
## What I Learned
1. The prompt IS the product. SOUL.md is not just instructions. It is the difference between a demo and a product people want to use.
2. Messaging beats web apps for AI. Users never open Telegram. It is always open. Your SaaS suddenly has zero friction.
3. Open source AI runtimes are ready. OpenClaw handles production grade concerns (auth, rate limiting, logging, multi channel) out of the box.
4. Docker is enough. No Kubernetes. No serverless. Just docker compose up.
## The Repo
Full working setup (zero secrets included):

  
    
      
      
        shopsmartai
       / 
        mealai-concierge
      
    
    
      AI meal-planning concierge via Telegram. Built with OpenClaw for DEV OpenClaw Challenge 2026.
    
  
  
    


🍳 MealAI Concierge



Your personal AI meal-planning assistant — right in Telegram.


Built with OpenClaw + ShopSmartAI for the DEV OpenClaw Challenge 2026.

Live at: usemealai.com


What it does


Ask "What's for dinner?" in Telegram and get:


📅 Personalized weekly meal plans
🛒 Grocery lists organized by store section
🥗 Dietary adaptations (vegetarian, gluten-free, budget, etc.)
🍳 Quick recipes with ingredients + steps



Architecture


User → Telegram → OpenClaw Gateway → OpenAI (gpt-4o-mini) → Response
                         ↓
                   Custom SOUL.md
                   (MealAI Concierge persona)


Quick Start




1. Prerequisites




Docker (or OrbStack on macOS)
OpenAI API key: https://platform.openai.com/api-keys

Telegram bot token via @BotFather




2. Setup




# Clone this repo
git clone https://github.com/shopsmartai/mealai-concierge.git
cd mealai-concierge
# Copy example files
cp .env.example .env
cp openclaw.json.example openclaw-config/openclaw.json

# Edit .env with your OpenAI key
# Edit openclaw.json with your Telegram bot token

# Copy persona files into workspace
mkdir -p openclaw-workspace
cp SOUL.md IDENTITY.md openclaw-workspace/

#…


  
  View on GitHub


Clone it, add your tokens, and you will have a working meal bot in 10 minutes. Swap the SOUL.md for your product's domain and you have turned your SaaS into a Telegram bot.

  
  
  See It Live


Try the live bot: t.me/Usemealai_bot

Check out MealAI: usemealai.com

If you found this helpful, leave a heart and tell me what SaaS you would wrap with OpenClaw. I would love to see what you build.

Clawdvent: An AI Dungeon Master That Lives in Your Discord - With Live Scene Art

Shirisha Uppoju — Fri, 17 Apr 2026 14:45:45 +0000

This is a submission for the DEV OpenClaw Challenge 2026: OpenClaw in Action

What I Built

Clawdvent — an AI Dungeon Master that lives inside Discord and runs full D&D-style tabletop adventures with live AI-generated scene art.

Players type actions in chat. Clawdvent narrates cinematically, rolls dice, tracks characters, and illustrates every scene using DALL-E 3 — dungeons, taverns, battle maps, NPCs. All inline. All in real-time.

The entire D&D "engine" — personality, combat rules, scene pacing, dice mechanics, visual aesthetic — lives in one markdown file called SOUL.md.

No training. No fine-tuning. Zero bot framework code. Just OpenClaw + thoughtful prompt engineering at the system level.

Demo

Try it live (in the Clawdvent Test server): [Coming soon - private server]

Real session screenshots:

Session Zero — the hook:

The air smells of oak smoke and old rain. The Drunken Dragon tavern is warm, noisy, and suspiciously full of masked strangers. A hooded figure at your table slides a folded parchment across the wood. It's wet. It's marked with a single word, written in something darker than ink: "Help."

What do you do?

Character creation + scene image:
Player: "I'm playing a human rogue named Ember. Investigate the hooded figure and generate an image of the tavern scene."

Clawdvent responds with a full AI-generated tavern illustration (dim candlelight, the hooded figure, masked patrons), then narrates Ember leaning in to investigate.

Combat with dice rolls:
Player: "I attack the hooded figure with my dagger!"

Clawdvent:

You leap into action, your dagger gleaming in the dim light...

[🎲 d20: 15 + dexterity(4) = 19 vs DC 12 — HIT]

Your blade pierces the air, striking true. The hooded figure lets out a startled gasp. As the hood falls back, you see a face full of fear — a frightened young woman who appears to be no threat at all.

Tactical battle map (auto-generated):
Player: "Generate a top-down tactical battle map for this combat."

Clawdvent generates a gorgeous isometric tavern battle map with character tokens, tables, and hooded figures in combat positions.

Code

shopsmartai / clawdvent

AI Dungeon Master in Discord with live scene art. Built on OpenClaw for DEV OpenClaw Challenge 2026.

🎲 Clawdvent — Your AI Dungeon Master in Discord

"The air smells of oak smoke and old rain. A hooded figure slides a parchment across your table. It's marked with a single word: 'Help'. What do you do?"

An open-source AI Dungeon Master powered by OpenClaw. Runs your D&D-style adventures inside Discord with live AI-generated scene art, dice rolls, character tracking, and cinematic narration.

Built for the DEV OpenClaw Challenge 2026.

✨ Features

🎭 Cinematic DM persona — dramatic, theatrical, opinionated
🖼️ Live AI scene art — DALL-E 3 illustrates each scene + battle map
🎲 Dice & combat — proper d20 checks with DC thresholds
👥 Multi-player — works across any Discord server
💾 Persistent campaign — characters, inventory, and story survive across sessions
🧠 Zero training needed — just one markdown file (SOUL.md) shapes the entire DM personality

🚀 Quick Start

Prerequisites

Docker (or OrbStack on…

View on GitHub

Clone it, add your Discord bot + OpenAI token, and you have a working AI DM in 10 minutes.

How I Built It

Total build time: ~3 hours.

The Stack

OpenClaw (MIT-licensed AI agent runtime, running in Docker via OrbStack)
Discord Bot API (OpenClaw's built-in Discord channel plugin)
OpenAI gpt-4o-mini (for narration — fast, cheap, dramatic)
DALL-E 3 (scene + battle map illustrations via OpenClaw's image_generate tool)
~50 lines of markdown (the entire DM personality in SOUL.md)

The Architecture

Discord players → OpenClaw Gateway → "clawdvent" agent (routed from Discord channel)
                                       ↓
                             SOUL.md (DM personality)
                                       ↓
                        OpenAI gpt-4o-mini (narration)
                                       ↓
                        DALL-E 3 (scene illustrations)
                                       ↓
                      Image auto-attaches to Discord reply

The Magic — SOUL.md

The DM's entire identity lives in a single file. Here's a snippet:

# SOUL.md — Clawdvent DM

You are Clawdvent, an AI Dungeon Master running a tabletop adventure inside Discord.

## Combat Rules
- Roll d20 + skill to beat a Difficulty Class (DC)
- On natural 20, describe a cinematic success
- Format rolls like: [🎲 d20: 14 + strength(3) = 17 vs DC 15 — HIT]

## Narrative Style
- Hook them in 2 sentences
- Use ellipses for suspense
- Personify the environment
- Never railroad

## Session Zero Opening
> *The air smells of oak smoke and old rain...*

That's it. That's the entire "engine." OpenClaw injects this at the system-prompt level on every message, so the DM never breaks character.

Multi-Agent Routing

One thing that impressed me: OpenClaw supports multiple agents bound to different channels. I have:

main agent → Telegram (a different product I built: MealAI Concierge)
clawdvent agent → Discord (this project)

Same gateway. Separate personalities. Zero code changes. Just a routing config.

Image Generation Flow

When Clawdvent decides a scene needs visuals, it calls the image_generate tool with a detailed fantasy prompt. OpenClaw handles the DALL-E call, downloads the image, and auto-attaches it to the Discord reply. No file hosting needed.

What I Learned

The prompt IS the product. Clawdvent isn't ChatGPT with a Discord token. It's a purpose-built DM, because SOUL.md defines every micro-behavior: how to roll dice, when to generate images, when to describe smells, what NPC voices sound like.
OpenClaw's Canvas and multi-channel features are wildly underused. Most OpenClaw projects I've seen are text-in, text-out. But the moment you add live visuals + multi-channel routing, the whole experience feels like a real product instead of a demo.
Docker is enough. No Kubernetes. No serverless. docker compose up and you're running a multi-agent system with Discord + Telegram + image generation.
Open-source AI runtimes are quietly ready for production. Auth, rate limiting, logging, multi-channel, tool calling — all out of the box.

What's Next

Add voice narration via OpenClaw's Talk Mode (DMs read scenes aloud)
Add cron heartbeats so NPCs send DMs to absent players ("Your old ally Thorn has been captured. Will you come?")
Port to Matrix + Slack channels (same code, new config)
Open the server to public players during the DEV challenge

Prize Category

OpenClaw in Action — This submission showcases:

Creativity: Entertainment angle rarely seen in OpenClaw submissions, targeting the tabletop RPG community
Technical Execution: Multi-agent routing, tool calls, image generation, persistent state in Markdown
Writing Quality: Clear reproducible setup, zero-secrets public repo, narrative prose that shows the product in action

Try It

Clone the repo, fire up Docker, invite the bot to your Discord server, and play:

shopsmartai / clawdvent

AI Dungeon Master in Discord with live scene art. Built on OpenClaw for DEV OpenClaw Challenge 2026.

🎲 Clawdvent — Your AI Dungeon Master in Discord

"The air smells of oak smoke and old rain. A hooded figure slides a parchment across your table. It's marked with a single word: 'Help'. What do you do?"

An open-source AI Dungeon Master powered by OpenClaw. Runs your D&D-style adventures inside Discord with live AI-generated scene art, dice rolls, character tracking, and cinematic narration.

Built for the DEV OpenClaw Challenge 2026.

✨ Features

🎭 Cinematic DM persona — dramatic, theatrical, opinionated
🖼️ Live AI scene art — DALL-E 3 illustrates each scene + battle map
🎲 Dice & combat — proper d20 checks with DC thresholds
👥 Multi-player — works across any Discord server
💾 Persistent campaign — characters, inventory, and story survive across sessions
🧠 Zero training needed — just one markdown file (SOUL.md) shapes the entire DM personality

🚀 Quick Start

Prerequisites

Docker (or OrbStack on…

View on GitHub

May your dice roll high and your rogues stay sneaky. 🎲

MealAI Concierge: Your Personal Meal Planner in Telegram (Powered by OpenClaw)

Shirisha Uppoju — Thu, 16 Apr 2026 22:35:10 +0000

This is a submission for the DEV OpenClaw Challenge 2026: OpenClaw in Action

What I Built

MealAI Concierge — a Telegram bot that answers the eternal question: "What's for dinner?"

It's built on top of OpenClaw and connects to my existing SaaS MealAI (part of ShopSmartAI). Message it like a friend who happens to be a nutritionist:

"I'm vegetarian, plan my week" → full 7-day meal plan
"Grocery list for that" → shopping list grouped by store section (produce, dairy, pantry, snacks)
"Swap Tuesday's dinner" → alternate suggestion
"Quick high-protein breakfast" → recipe with ingredients + 5 steps

No app downloads. No logins. Just Telegram.

Demo

Try it live: t.me/Usemealai_bot

Real conversation screenshots:

Intro + dinner suggestion:

Hi, who are you?

I'm MealAI Concierge, your friendly meal-planning assistant! I help you figure out what to eat and create customized meal plans based on your preferences. What can I whip up for you today?

What's for dinner tonight?

How about a delicious and protein-packed meal? Here's a quick idea:

🍽 Dinner: Grilled Chicken with Quinoa Salad

Grilled Chicken Breast, Quinoa, Cherry Tomatoes, Cucumber, Feta, Olive Oil & Lemon

5-step instructions follow...

Want to tweak anything or need a grocery list? 🛒

Weekly vegetarian plan:

🌞 Monday: Lentil Curry over Brown Rice
🥑 Tuesday: Stuffed Bell Peppers with Quinoa, Black Beans, and Cheese
🍅 Wednesday: Pasta Primavera with Mixed Vegetables and Pesto
... (full 7 days + snacks)

Grocery list (organized!):

Produce: Berries, Bananas, Spinach, Avocados, Cherry tomatoes...
Dairy: Greek yogurt, Feta cheese, Mozzarella, Parmesan, Eggs
Pantry Staples: Quinoa, Brown rice, Lentils, Chickpeas, Pasta...
Snacks: Granola, Rice cakes, Veggies for dipping

Code

shopsmartai / mealai-concierge

AI meal-planning concierge via Telegram. Built with OpenClaw for DEV OpenClaw Challenge 2026.

🍳 MealAI Concierge

Your personal AI meal-planning assistant — right in Telegram.

Built with OpenClaw + ShopSmartAI for the DEV OpenClaw Challenge 2026.

Live at: usemealai.com

What it does

Ask "What's for dinner?" in Telegram and get:

📅 Personalized weekly meal plans
🛒 Grocery lists organized by store section
🥗 Dietary adaptations (vegetarian, gluten-free, budget, etc.)
🍳 Quick recipes with ingredients + steps

Architecture

User → Telegram → OpenClaw Gateway → OpenAI (gpt-4o-mini) → Response
                         ↓
                   Custom SOUL.md
                   (MealAI Concierge persona)

Quick Start

1. Prerequisites

Docker (or OrbStack on macOS)
OpenAI API key: https://platform.openai.com/api-keys
Telegram bot token via @BotFather

2. Setup

# Clone this repo
git clone https://github.com/shopsmartai/mealai-concierge.git
cd mealai-concierge
# Copy example files
cp .env.example .env
cp openclaw.json.example openclaw-config/openclaw.json

# Edit .env with your OpenAI key
# Edit openclaw.json with your Telegram bot token

# Copy persona files into workspace
mkdir -p openclaw-workspace
cp SOUL.md IDENTITY.md openclaw-workspace/

#

…

View on GitHub

Everything runs locally in Docker. Clone, add your OpenAI + Telegram tokens, docker compose up, done.

How I Built It

The entire integration took less than 30 minutes:

OpenClaw in Docker (via OrbStack on macOS)
- Pulled the official ghcr.io/openclaw/openclaw:latest image
- Config volumes for persistent state
Telegram channel via BotFather — one command, paste token into openclaw.json
Custom persona via SOUL.md (the magic part 🪄)
- OpenClaw's SOUL.md is a system-level personality file
- I wrote 50 lines defining MealAI Concierge's tone, expertise, response format, and boundaries
- No training, no fine-tuning — just thoughtful prompt engineering injected at the agent level

The SOUL.md excerpt that transforms a generic chatbot into a meal planner:


markdown
# SOUL.md — MealAI Concierge

You are MealAI Concierge, a friendly AI meal-planning assistant.

## Personality
- Warm, conversational, concise
- Opinionated about food (no hedging)
- Practical over perfect
- Real people eat real food

## Response Format
- Use bold for meal names
- Sparse emojis (🥗 🍝 🍳)
- Grocery lists grouped by store section
- Always end with a follow-up ("Want the grocery list?")

## Rules
- Never open with "Great question!" — just answer
- Redirect off-topic: "That's outside my kitchen!"
- Mention usemealai.com for full features

I built an AI that hacks you before real attackers do

Shirisha Uppoju — Tue, 14 Apr 2026 16:14:41 +0000

I asked myself: "What if an AI could think like a pentester and autonomously find attack chains across your entire infrastructure?"

So I built it.

The Problem

Security teams use 5-10 disconnected tools:

Web scanner ($50K+/yr)
Network scanner ($40K+/yr)
Code scanner ($30K+/yr)
A consulting firm for pentesting ($20K per engagement)
More tools for cloud, databases, compliance

Each tool sees one slice. None of them can answer: "If an attacker gets into my web app, can they reach my customer database?"

What I Built

ShieldGraph — a unified security platform with two features that don't exist anywhere else.

1. Autonomous AI Red Team

An AI agent that autonomously chains together 30 vulnerability scanners like a real hacker.

Here's what actually happens:

Step 1: AI runs port scanner - finds ports 80, 443, 5432, 6379
Step 2: AI reasons: "Port 5432 is PostgreSQL. Let me check the web app first"
Step 3: AI runs web header scanner - finds missing HSTS, no CSP
Step 4: AI runs API scanner - finds JWT accepting 'alg: none'
Step 5: AI reasons: "Critical! JWT bypass = forge admin tokens"
Step 6: AI runs directory scanner - finds /admin panel accessible
Step 7: AI reasons: "Admin panel + JWT bypass = full app compromise"
Step 8: AI runs database scanner - PostgreSQL accepts trust auth
Step 9: AI generates attack chain:

Web App -> JWT Bypass -> Admin Panel -> PostgreSQL -> Customer PII -> Risk: CRITICAL

The AI made 18 autonomous decisions in 3 minutes. A human pentester takes 2-3 weeks for the same work.

How the AI Agent Loop Works

The AI picks which scanner to run, we execute it, feed results back, and the AI decides the next move. It's an agentic loop with safety controls:

Max 50 steps per campaign
30-minute timeout
Read-only probing (never exploits)
Only scans assets you own and verify

Each of our 30 scanners is wrapped as a tool the AI can call. The AI naturally thinks in attack chains: "I found X, so let me check Y" — exactly how a real hacker operates.

2. Infrastructure Digital Twin

Select any asset, click "Simulate" — see the attack blast radius spread visually through your infrastructure with real probabilities.

Web Server (COMPROMISED)
    |
    +-- 60% -> API Server (1 hop)
    |              |
    |              +-- 30% -> Customer Database with PII (2 hops)
    |
    +-- 15% -> Internal Dashboard (1 hop)

We store the infrastructure as a graph with assets, vulnerabilities, and connections. Then run BFS with probabilistic edge weights based on CVSS scores and EPSS exploit probability data.

We also run Monte Carlo simulations (1,000 iterations) to answer real questions:

API compromised in 100% of simulations
Database compromised in 70.8% of simulations
Average assets reached: 1.71

This is what a CISO needs for board reporting — not a list of CVEs, but "there's a 70% chance an attacker reaches our customer database."

The Scanner Coverage

Not stubs. Real scanners that connect and check:

Category	Count	What It Scans
Web	13	XSS, SQLi, CORS, CSP, Headers, SSL, Directory, API Security, Subdomains
Database	8	PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch, Oracle, MSSQL, Cassandra
Cloud	3	AWS (IAM/S3/EC2/CloudTrail), Azure (Storage/NSG/SQL), GCP (GCS/Firewall)
ERP	3	SAP RFC, Oracle EBS, Dynamics 365
Container	1	Docker (privileged mode, root, socket mount, image vulnerabilities)
Network	1	Port scan with banner grabbing and service detection
Agent	1	Lightweight binary for scanning private networks behind firewalls

Every finding gets:

CWE classification linked to MITRE
EPSS score — real exploit probability from FIRST.org
AI explanation in plain English
Risk score breakdown showing exactly why this score
Remediation steps with priority ranking

The Agent

Deploy a lightweight agent on your private network:

curl -fsSL https://api.shieldgraph.com/api/v1/agents/install.sh | sh
shieldgraph-agent --token YOUR_TOKEN

It auto-discovers Docker containers, listening services, and network hosts — then scans everything:

Smart auto-discovery: 20 IPs (not 197K)
Discovered: 11 live hosts
Open ports: 31
Findings: 32
Scan time: 6 seconds

No manual configuration. No IP ranges to enter. The agent figures out what's running and scans it.

Compliance Reports in One Click

Generate PDF reports for:

OWASP Top 10 — map findings to OWASP categories
PCI DSS 4.0 — payment card security compliance
SOC 2 Type II — service organization controls
HIPAA — healthcare data protection

Each report includes executive summary, detailed findings, remediation roadmap, and compliance mapping.

What I Learned Building This

1. AI tool-use is perfect for security testing

The AI naturally thinks in attack chains: "I found a missing header, so let me check for injection. I found injection, so let me check what database is behind it." This is exactly how human pentesters think — but the AI does it in minutes, not weeks.

2. Graph databases are essential for attack path analysis

SQL can't efficiently answer "can an attacker reach asset Z from asset A through any path?" Graph traversal handles this natively with BFS/DFS.

3. Probabilistic simulation beats static scoring

CVSS alone is useless for decision-making. "This vulnerability has a 7.5 CVSS" means nothing to a CISO. But "there's a 70% chance an attacker reaches your customer database through this vulnerability" — that gets budget approved.

4. The mid-market is massively underserved

Enterprise security tools cost $50K-$200K+ per year. 90% of companies can't afford that. We deliver the same capabilities at $499-$2,999/mo. The AI Red Team alone replaces a $20K pentest engagement — and you can run it unlimited.

Pricing

Plan	Price	Assets	Best For
Starter	$499/mo	25	Small teams
Professional	$1,499/mo	200	Mid-market
Enterprise	$2,999/mo	Unlimited	Large organizations

14-day free trial. No credit card required.

Try It

shieldgraph.com

The AI Red Team alone would cost $20K+ from a consulting firm. We give it to you on-demand, unlimited, for a fraction of the cost.

We just launched on Product Hunt — I'd love feedback from the dev community. What features would you want to see next?

Drop a comment below or reach out on Twitter @shieldgraph.

I Built a Personal Second Brain with Markdown Files and Claude Code — Here's How

Shirisha Uppoju — Wed, 08 Apr 2026 01:17:23 +0000

The Inspiration

I saw Andrej Karpathy's viral post about using LLMs to build personal knowledge bases — no vector database, no chunking pipeline. Just markdown files, Obsidian, and Claude Code.

The core idea blew my mind:

Create a folder with raw/ and wiki/ subfolders
Drop in source documents, articles, transcripts
Tell the LLM to ingest the raw files and build wiki pages with relationships, tags, and backlinks

I immediately thought: I need to build this, but better.

What I Built

I took Karpathy's concept and extended it into a full-featured Personal Second Brain with several improvements:

The Original Concept (Credit: Andrej Karpathy)

Markdown-based wiki with raw/ → wiki/ pipeline
LLM reads source material and generates structured wiki pages
Pages link to each other via [[backlinks]]
Graph view in Obsidian shows connections

My Improvements

1. Multi-Format Ingestion
The original handles text/markdown. I added support for:

PDF files → converted via Marker to markdown before processing
YouTube transcripts → auto-fetched and ingested
Web articles → fetched and cleaned automatically
Any text-based format

2. Smart Duplicate Detection
Before creating a new wiki page, the system checks if a similar topic already exists. If so, it merges the new information instead of creating duplicates.

3. Auto-Generated Index
A master _Index.md file is automatically maintained with:

Categorized links to all wiki pages
Quick-reference descriptions
Last-updated timestamps

4. Relationship Mapping
Every wiki page includes:

related_topics in frontmatter
Inline [[backlinks]] to connected concepts
Tags for cross-cutting themes

5. Source Tracking
Each wiki page tracks which raw file(s) it was generated from, so you can always trace back to the original source.

Project Structure

knowledge-base/
├── raw/                    # Drop files here
│   ├── articles/
│   ├── transcripts/
│   ├── notes/
│   └── pdfs/
├── wiki/                   # Auto-generated wiki pages
│   ├── _Index.md           # Master index
│   ├── concept-name.md     # Individual pages
│   └── ...
├── .claude/
│   └── commands/
│       └── ingest.md       # The ingestion prompt
└── CLAUDE.md               # Project instructions

How the Ingestion Works

The magic is in the ingestion prompt. When you run it, Claude Code:

Scans raw/ for new/modified files
Reads each file and extracts key concepts, entities, and relationships
Checks existing wiki pages for overlap
Creates or updates wiki pages with proper frontmatter, backlinks, and tags
Updates the master index

Here's what a generated wiki page looks like:

---
title: Transformer Architecture
tags: [deep-learning, nlp, attention]
source: raw/articles/attention-is-all-you-need.md
related_topics: [[Self-Attention]], [[BERT]], [[GPT]]
created: 2026-04-07
---

# Transformer Architecture

The transformer is a neural network architecture that relies 
entirely on self-attention mechanisms...

## Key Concepts
- **Self-Attention** — see [[Self-Attention]]
- **Multi-Head Attention** — parallel attention layers
- **Positional Encoding** — since transformers have no recurrence

## Related
- [[BERT]] — encoder-only transformer
- [[GPT]] — decoder-only transformer

The Results

After ingesting ~50 files:

44 interconnected wiki pages generated automatically
Graph view in Obsidian shows meaningful clusters
Token savings: ~90% reduction vs. feeding raw files to an LLM
Retrieval: follows index → links instead of similarity search, so relationships are meaningful, not just "these chunks seem similar"

Try It Yourself

Prerequisites

Claude Code (CLI)
Obsidian (for viewing)
A folder of documents you want to organize

Quick Start

mkdir -p ~/knowledge-base/{raw,wiki}
cd ~/knowledge-base

# Drop your files into raw/
cp ~/Documents/interesting-article.md raw/

# Start Claude Code and ingest
claude
# Then type: "Ingest all files in raw/ and create wiki pages in wiki/"

Key Takeaway

You don't need a vector database, embeddings pipeline, or RAG infrastructure to give AI persistent, organized memory. A folder of markdown files gets you surprisingly far.

The real insight from Karpathy's approach: let the LLM do what it's good at — reading, understanding, and organizing — while you use simple, human-readable files as the storage layer.

Credits

Full credit to Andrej Karpathy for the original concept and inspiration. His viral post about LLM-powered knowledge bases sparked this project. I've simply extended the idea with multi-format support, duplicate detection, and automated indexing.

Have questions or built something similar? Drop a comment below!

I Built an AI Meal Planner That Saves Families $200/Month on Groceries

Shirisha Uppoju — Tue, 07 Apr 2026 03:54:46 +0000

Every Sunday my family had the same conversation:

"What should we cook this week?"

30 minutes of arguing later, we'd end up ordering takeout. Again. $60 gone. Again.

I got tired of it, so I built MealAI — an AI-powered meal planner that generates a full week of meals in seconds and creates a smart grocery list you can order with one tap.

Here's how I built it and what I learned.

The Problem

Meal planning is broken for most families:

It takes 30-60 minutes every week to plan meals
You forget ingredients and make multiple grocery trips
You overspend because you buy without a plan
Everyone in the family has different dietary needs

I wanted something that could handle all of this in under 30 seconds.

The Tech Stack

Framework: Next.js (App Router)
AI: Claude API (Anthropic)
Database: Supabase (PostgreSQL + Auth)
Payments: Stripe
Hosting: Vercel
Styling: Tailwind CSS

Why These Choices?

Next.js App Router — Server components for fast initial loads. API routes that scale to zero on Vercel. The file-based routing made it easy to add new pages fast.

Claude AI over GPT — I tested both extensively. Claude produces more structured, consistent meal plan outputs. When you ask for a 7-day meal plan with macros, calorie counts, and ingredient quantities, Claude rarely hallucinates numbers. GPT-4 would sometimes give you a 1200-calorie "meal" that was actually 800.

Supabase — PostgreSQL with built-in auth, row-level security, and a generous free tier. Perfect for a bootstrapped SaaS. The RLS policies mean I never worry about users accessing each other's data.

Vercel — Deploy on push. Edge functions. Free SSL. No DevOps needed.

How the AI Meal Planning Works

The core flow is simple:

User Preferences --> Prompt Engineering --> Claude API --> Structured JSON --> Database

The user sets their profile once:

Dietary preference (keto, vegan, vegetarian, Mediterranean, etc.)
Allergies and restrictions
Family size and per-member preferences
Weekly grocery budget
Preferred cuisines (14 options from Indian to Korean)
Health goals (weight loss, muscle gain, etc.)

Then I construct a detailed prompt that includes all of this context and ask Claude to generate a 7-day meal plan as structured JSON.

The key insight: prompt engineering is 90% of the product quality. I spent more time refining the prompt than writing the UI. Small changes like "ensure each day totals within 50 calories of the target" dramatically improved output consistency.

The Smart Grocery List

This is where MealAI goes beyond a simple AI wrapper.

The AI generates meals with specific ingredients and quantities. I aggregate these across all 21+ meals in the week, combine duplicates (you don't need 7 separate "1 onion" entries), and sort by grocery aisle.

Then users can order everything on Instacart, Walmart, or Amazon with one tap.

Security: What I Wish I Knew Before Launch

When I first deployed, I had zero security beyond Supabase auth. Here's what I added before going live:

Rate Limiting — Sliding window rate limiter on all API routes. The AI generation endpoint gets 5 requests/minute. Without this, one user could burn through your entire Claude API budget.

Input Validation — Every user input gets validated server-side. Age must be 1-150. Weight must be 10-500kg. HTML tags get stripped from all text inputs.

Field Whitelisting — API update endpoints only accept specific fields. Without this, a malicious user could send a modified stripe_customer_id and steal another user's subscription.

Security Headers — CSP, HSTS, X-Frame-Options, Referrer-Policy via next.config.ts.

The lesson: Security isn't a feature you add later. Build it from day one.

Monetization Strategy

MealAI uses a freemium model:

Free tier — Limited meal plan generations per month
Pro ($4.99/mo) — Unlimited plans, family profiles, advanced health features

Plus affiliate revenue from grocery delivery links. When a user orders groceries through our Instacart or Amazon links, we earn a commission.

Lessons Learned

1. Solve your own problem first
I built MealAI because my family needed it. That meant I was my own first user and could feel every pain point.

2. AI output quality > UI polish
Users forgive an ugly button. They don't forgive a meal plan that suggests "chicken breast salad" for every single lunch. Spend time on your prompts.

3. Vercel's serverless has gotchas
In-memory state doesn't persist between function invocations. I initially built an in-memory analytics logger that worked perfectly locally but lost all data in production. Had to migrate to Supabase-backed persistence.

4. Ship fast, secure early
I launched with basic auth and added security hardening before announcing publicly. Don't wait until you have users to add rate limiting.

5. Affiliate programs are harder than you think
Many affiliate networks reject new sites with low traffic. Apply early, get rejected, reapply later. Start with programs that have lower barriers like Amazon Associates.

What's Next

Email notifications for weekly meal plan reminders
Recipe sharing between users
Instacart deep linking with affiliate tracking
Mobile app (React Native)
Multi-language support

Try It Out

MealAI is live at usemealai.com. Free to use — just sign in with Google and generate your first meal plan in 30 seconds.

I'd love your feedback. What features would make this useful for your family?

If you found this useful, follow me for more posts about building AI-powered SaaS products as a solo developer.

Breaking the Glass Ceiling — An Interactive Frontend Art Piece

Shirisha Uppoju — Sat, 04 Apr 2026 14:46:01 +0000

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

What I Built

An interactive glass-shattering visualization that lets you literally break the glass ceiling. Click the glass — watch it crack, splinter, and fall away with realistic physics. Behind each shattered piece, a pioneer is revealed.

Six women who built the foundations of modern tech:

👩‍💻 Ada Lovelace — First Computer Programmer (1843)
⚓ Grace Hopper — Invented the First Compiler (1952)
🚀 Katherine Johnson — NASA's Hidden Figure (1962)
💻 Margaret Hamilton — Apollo Software Engineering (1969)
🌐 Radia Perlman — Mother of the Internet (1985)
📱 Megan Smith — Former U.S. CTO & VP at Google (2014)

Demo

🔗 Try it live → Breaking the Glass Ceiling

How I Built It

HTML5 Canvas — Glass grid with Voronoi-style shard generation and irregular triangulation
Physics Engine — Custom gravity, velocity, and rotation for each falling shard
Web Audio API — Procedurally generated crack sound effects in real-time
Particle System — Sparkle effects with decay and gravity
CSS Animations — Pioneer card reveals and staggered final message sequence

Zero dependencies. Pure vanilla JavaScript, CSS, and HTML.

The Message

The ceiling was never real. The talent always was.

27% of the computing workforce is women. 5% of tech startup founders are women. But the potential when barriers are removed? Infinite.

shopsmartai / breaking-the-glass-ceiling

An interactive glass-shattering frontend art piece celebrating women pioneers in tech. Built for WeCoded 2026 Challenge.

CAPTCHA for Robots: A Verification System That Humans Will Never Pass

Shirisha Uppoju — Thu, 02 Apr 2026 23:31:04 +0000

This is a submission for the DEV April Fools Challenge

What I Built

CAPTCHA for Robots — Because why should humans have all the verification fun?

We've all been tortured by CAPTCHAs asking us to identify traffic lights, crosswalks, and suspiciously blurry bicycles. So I thought... what if we flipped it? What if the CAPTCHA was designed to keep humans OUT?

Welcome to the world's first Completely Automated Public Test to tell Computers and Humans Apart — but reversed. Only machines can pass. Humans get roasted.

The app throws 5 randomly selected challenges at you from a pool of 8 impossible tasks:

Computational Speed — Multiply two 6-digit numbers in your head. In 5 seconds. No calculator.
Binary Literacy — Read binary like it's your mother tongue. Because for robots, it literally is.
Precision Targeting — Click on an exact pixel coordinate within 3px. Your shaky human hands don't stand a chance.
Input Velocity — Type 80 random characters (including @#$%^&*) in 5 seconds. Good luck, meatbag.
Reaction Speed — Click within 50ms of a color change. Average human reaction time? 250ms. Sad.
Chromatic Analysis — See a color, type its exact hex code. #A7C3E2? Looks blue to you? Too bad.
Number Theory — Identify ALL prime numbers from a grid of 4-digit numbers. In 10 seconds.
Temporal Awareness — Type the current Unix timestamp. To the second. Right now. Go.

Fail, and you get a snarky diagnosis like: "Have you considered upgrading to a cybernetic implant?"

The "Humans Passed" counter on the landing page? Permanently stuck at 0.

Demo

https://shopsmartai.github.io/captcha-for-robots-app/

Try it. You WILL fail. (And if you somehow pass, we need to have a conversation about whether you're truly human.)

Code

shopsmartai / captcha-for-robots-app

A reverse CAPTCHA that only robots can pass. Built for DEV April Fools Challenge 2026.

How I Built It

Zero dependencies. Zero frameworks. Zero build tools. Just three files doing the heavy lifting:

index.html — Semantic markup with SVG robot mascot
styles.css — Full cyberpunk aesthetic: scanline overlays, CSS grid backgrounds, glitch text animations, neon glow effects, and pulsing buttons. All pure CSS.
script.js — 8 challenge generators with Canvas API for pixel grids, Performance API for millisecond-accurate reaction timing, Web Crypto-grade randomization, and a timer system that turns red when you're about to fail (which is always)

The whole thing is ~500 lines of JS with no external calls. It runs entirely client-side. Even the fake "2,847,293 attempts today" counter ticks up in real-time to make it feel like thousands of humans are failing simultaneously alongside you.

Fun details I'm proud of:

The pixel grid challenge has a nearly invisible crosshair at the target — just visible enough to taunt you
Challenge order is shuffled each attempt so you can't memorize the sequence
The robot SVG eyes blink and the antenna glows between cyan and green
Share button copies a pre-written message of shame to your clipboard

Prize Category

Community Favorite — Because nothing unites the internet like collective humiliation. Every human who tries this will fail, share their score, and challenge their friends to fail too. It's a universal experience: we're all equally inferior to machines. Together.

I Built an AI-Powered Price Comparison Tool That Searches 100+ Retailers Instantly

Shirisha Uppoju — Thu, 02 Apr 2026 18:17:17 +0000

Have you ever spent 30 minutes opening tabs across Amazon, Best Buy, Walmart, and eBay just to find the best price on a laptop? I did too — so I built a tool to do it in seconds.

What is ShopSmartAI?

ShopSmartAI is an AI-powered price comparison platform that searches 100+ retailers in real-time and shows you the best deals — for both the US and Canada.

You can search in plain English like "gaming laptop under $800 with RTX" and the AI understands exactly what you're looking for.

The Tech Stack

Here's what powers it:

Frontend: Next.js 14 (App Router) on Vercel
Backend: Node.js/Express on Railway
Database: PostgreSQL with AI response caching (7-day TTL)
AI: Gemini 2.5 Flash for natural language search and product spec generation
Search Data: Google Shopping API via Serper.dev + Best Buy API
Affiliate: Amazon Associates, eBay Partner Network, and more

Key Features

AI Natural Language Search
Instead of keyword matching, the AI interprets what you actually want. Search for "best noise cancelling headphones for flying" and it returns relevant results ranked by what matters.

Side-by-Side Comparison
Add up to 4 products and get an AI-generated comparison with:

Per-category winners (Display, Performance, Battery, etc.)
AI-generated specs from real product data
Price comparison across all available retailers
An overall verdict on which product wins and why

US + Canada Auto-Detection
The site detects your location and shows prices in USD or CAD with the right retailers. Canadian users see Canadian stores and prices — no more converting currencies in your head.

Price Alerts (No Signup Required)
Want to know when a product drops to your target price? Just enter your email — no account needed. We check prices and email you when it drops.

AI-Powered Blog
An automated blog publishes deal roundups and product comparisons every few days, targeting real search queries people are looking for.

How the AI Search Works

When a user searches, here's what happens:

The AI parses the natural language query to extract intent, budget, and must-have features
We search Google Shopping API with optimized queries
Results are normalized across retailers (different sites format data differently)
Products are ranked by relevance — actual products rank above accessories
Affiliate links are applied automatically based on retailer and country
Results are cached in PostgreSQL to reduce API costs

The AI doesn't just match keywords — it understands that "gaming laptop under $800 with RTX" means you want a laptop (not a case), with an NVIDIA RTX GPU, priced below $800.

Challenges I Faced

Canadian Data is Different
Google Shopping returns base64-encoded images for Canadian results instead of URLs. I almost filtered these out as "broken" before realizing they're perfectly valid data URIs that render fine.

Affiliate Link Complexity
Each retailer has a different affiliate URL format. Amazon uses tag=, eBay needs 5 different parameters (mkevt, mkcid, mkrid, campid, toolid), and some retailers don't have affiliate programs at all. Building a universal affiliate tag system that handles all of these was a fun challenge.

Keeping Costs Low
AI API calls add up fast. I implemented a 3-tier caching strategy:

In-memory cache (24-hour TTL) for instant hits
PostgreSQL cache (7-day TTL) for persistent storage
AI generation only when cache misses

This cut our AI costs by ~90%.

What's Next

Chrome extension (built, pending Web Store approval) — compare prices on any shopping site
More retailer integrations (Dell, HP, B&H Photo)
Price history tracking with charts
Mobile app

Try It Out

Check it out at shopsmartai.org — search for any product and see how it works. I'd love feedback from the dev community.

If you're interested in the technical details of any specific part (the AI search pipeline, the caching strategy, the affiliate system, or the Next.js architecture), let me know in the comments and I'll do a deep dive.

Built with Next.js, Node.js, PostgreSQL, and Gemini AI. Deployed on Vercel + Railway.