DEV Community: Nilesh Jethwa

I Built a Simple AI Visibility Tracker in Python. Here’s What Breaks When You Scale It

Nilesh Jethwa — Tue, 22 Sep 2026 20:20:14 +0000

I Built a Simple AI Visibility Tracker in Python. Here’s What Breaks When You Scale It

AI visibility tracking sounds like a fairly simple programming problem.

Ask ChatGPT a question.

Check whether a brand appears in the answer.

Save the result.

Repeat tomorrow.

And honestly, at first, it is that simple.

You can build a primitive AI visibility tracker in a few lines of Python.

from openai import OpenAI
from datetime import datetime

client = OpenAI()

brand = "Acme"

prompts = [
    "What are the best project management tools?",
    "What are good alternatives to Trello?",
    "What project management software is best for small businesses?",
    "Which project management tools have AI features?",
    "What tools can remote teams use to organize projects?"
]

results = []

for prompt in prompts:

    response = client.responses.create(
        model="gpt-5.4-mini",
        input=prompt
    )

    answer = response.output_text

    results.append({
        "prompt": prompt,
        "mentioned": brand.lower() in answer.lower(),
        "response": answer,
        "checked_at": datetime.utcnow().isoformat()
    })

visibility = (
    sum(r["mentioned"] for r in results)
    / len(results)
) * 100

print(f"{brand} visibility: {visibility:.1f}%")

If Acme appears in two of five responses, we could call that 40% visibility.

Done.

Well... not quite.

I recently worked through this problem while building the AI visibility tracking system behind CrawlSpider, and the interesting part wasn't making the LLM API call.

It was everything that happened after that.

The innocent-looking nested loop

Conceptually, an AI visibility tracker looks something like this:

for each brand:
    for each prompt:
        for each model:
            ask the model
            save the response
            find the brand
            find competitors
            calculate metrics

That looks harmless.

But consider:

100 brands
× 50 prompts
× 3 models
× daily scans

That's 15,000 requests every day.

Or 450,000 model responses every month.

Move to 1,000 brands and you're dealing with millions.

And suddenly this:

for prompt in prompts:
    call_llm(prompt)

isn't really the architecture anymore.

You need a queue

The first thing that breaks is the simple loop.

What happens if request #8,742 fails?

What happens when an API starts returning rate-limit errors?

What if one provider slows down?

What if your worker crashes halfway through a batch?

You don't want to restart everything.

So the architecture starts becoming something like:

Scheduler
    ↓
Scan Generator
    ↓
Job Queue
    ↓
Worker Pool
    ↓
LLM Provider
    ↓
Response Store

Now you need:

retries
exponential backoff
concurrency controls
job states
idempotency
dead-letter handling
rate-limit management
monitoring

We've moved surprisingly far away from our original Python script.

Then `brand in response` breaks

Our prototype has another wonderfully naive line:

brand.lower() in answer.lower()

Try that with:

brand = "Apple"

Did the model mention Apple Inc.?

Or an apple?

What about abbreviations?

Product names?

Parent companies?

And simply knowing that a brand appeared isn't particularly interesting.

Suppose the response says:

For enterprise teams I'd consider Acme or Monday.com,
while smaller teams might prefer Trello.

Now I probably want something closer to:

{
  "target_brand": {
    "mentioned": true,
    "position": 1
  },
  "competitors": [
    {"name": "Monday.com", "position": 2},
    {"name": "Trello", "position": 3}
  ]
}

The tracker has quietly turned into an entity extraction and classification system too.

The real product is history

Here's another realization I had while working on this.

A single AI response isn't particularly valuable.

Change is valuable.

Imagine seeing this:

"Best project management software for small businesses?"

Week 1    Acme not mentioned
Week 2    Acme #5
Week 3    Acme #3
Week 4    Acme #2

That's interesting.

But now every observation potentially needs:

brand_id
prompt_id
model_id
model_version
timestamp
raw_response
brand_mentioned
brand_position
competitors
sentiment
citations
token_usage
latency
status

Multiply that by millions of responses.

You're not storing API results anymore.

You're building a historical analytics dataset.

Multiple models make things more interesting

Then you decide that monitoring one AI model isn't enough.

Maybe you want:

providers = [
    "openai",
    "anthropic",
    "google"
]

Each has different APIs, response structures, rate limits, model identifiers, errors, citations and pricing.

Eventually you want an abstraction like:

                 ┌── OpenAI Adapter
Prompt Engine ───┼── Anthropic Adapter
                 └── Google Adapter
                         ↓
                 Normalized Response

Otherwise provider-specific logic ends up everywhere.

Scheduling becomes a system of its own

Then users ask for:

Prompt A → Daily
Prompt B → Weekly
Prompt C → Daily
Prompt D → Manual

Now something has to determine what is due.

And prevent duplicate runs.

And recover failed jobs.

And calculate the next run.

And make sure one huge account doesn't consume the entire worker pool.

At this point the "AI visibility tracker" is really a distributed job-processing and analytics application that happens to call LLMs.

AI responses aren't deterministic either

There's another subtle problem.

Run:

What are the best tools for X?

today and your brand might appear.

Run the exact same prompt tomorrow and it might not.

That doesn't necessarily mean the brand suddenly became less visible.

LLM responses vary.

So when a dashboard says:

Visibility

Last week: 42%
This week: 38%

what does that actually mean?

Is something changing?

Or are we observing normal model variation?

This makes prompt consistency, sample size, model versions and historical comparison surprisingly important.

API cost isn't the only scaling problem

It's natural to focus on token costs.

Those certainly matter when you're running hundreds of thousands or millions of requests.

But I found the more interesting cost to be engineering complexity.

At scale you're paying for much more than inference:

LLM inference
+ queues
+ workers
+ databases
+ storage
+ scheduling
+ retries
+ observability
+ analytics
+ provider maintenance
+ engineering time

And every new dimension multiplies the workload:

brands
× prompts
× models
× scan frequency
× time

That's the equation I'd pay attention to when designing one of these systems.

We had a useful head start

One reason we were able to build this into CrawlSpider is that we weren't starting completely from zero.

I'd previously built pieces of this kind of infrastructure for other projects.

InfoCaptor had given us experience with analytics, visualization and AI-driven workflows.

CrawlSpider's existing internal-linking system already dealt with crawling, page analysis, background processing and large collections of URLs.

Other projects had already forced us to solve problems around scheduled jobs, APIs, queues and asynchronous processing.

The AI visibility tracker became less about inventing every component and more about assembling those existing patterns around a new workflow:

Brand
  ↓
Prompts
  ↓
Models
  ↓
Scheduled scans
  ↓
Responses
  ↓
Mentions + competitors
  ↓
Historical metrics
  ↓
Dashboard

That reuse turned out to be extremely valuable.

The interesting lesson

Could you build an AI visibility tracker yourself?

Absolutely.

In fact, I think building the five-prompt Python version is a great weekend project.

The core algorithm can fit on one screen.

But that's also what makes this problem interesting.

There is a huge gap between:

"Call an LLM and see if my brand appears."

and:

"Reliably monitor thousands of brands across
multiple models every day and explain how their
visibility is changing."

The first is an API call.

The second is a platform.

I wrote a much deeper breakdown of the architecture, scaling math, infrastructure and costs while documenting how we approached this at CrawlSpider:

How to Build an AI Visibility Tracker From Scratch

If you're building something similar, I'd be interested in hearing how you're approaching the scheduling, normalization and non-determinism problems.

PS:
I also built a AI Adoption visualization Dashboard , check out!

I also maintain LLM cutoff dates for major providers
https://www.crawlspider.com/llm-knowledge-cutoff-dates/

Lastly there are 50+ brands monitored for their AI Visibility

How I Built Vizbull: Turning Photos Into AI-Generated Art

Nilesh Jethwa — Mon, 25 Aug 2025 18:20:33 +0000

Like most of us, I’ve spent countless hours tinkering with generative AI—experimenting with prompts, trying new models, and wondering: could this be turned into something useful, fun, and beautiful?

That itch eventually led me to build Vizbull
— an AI-powered image transformation tool that lets anyone turn their photos into line art, cartoons, watercolors, or even custom coloring pages.

It started as a weekend experiment. Today, it’s a growing SaaS project with paying users, real workflows, and integrations on the roadmap. In this post, I’ll share:

✅ What Vizbull does and why I built it

⚙️ The tech stack behind the scenes

🚀 How I’m approaching monetization & growth

👀 What’s next

🖌️ What Vizbull Does

At its core, Vizbull is simple:

Upload any photo (portrait, pet, landscape, product)

Choose a style (cartoon, Tintin-style, anime, watercolor, pop-art, etc.)

Get a transformed image in seconds

But the magic isn’t just in the styles—it’s in creative use cases:

Artists use it to generate line art references for sketching

Parents turn family portraits into coloring pages for kids

Creators make cartoon profile pictures for TikTok/Instagram

Businesses design branded character art without hiring a studio

⚙️ The Tech Behind Vizbull

Since Dev.to readers love the build side, here’s a quick peek under the hood:

Frontend: Vanilla JS + jQuery with Bootstrap for fast iteration (yes, I kept it simple intentionally)

Backend: Serverless AWS Lambda (Node.js)

Image Processing: OpenAI Image APIs (edit/variation) + custom style prompts + some post-processing scripts

Storage & Delivery: S3 for images, SES for emailing results

Payments: Stripe micro-credits system (buy credits → use them per transformation)

One design principle: low friction. No complex accounts needed to test. Users can upload, try styles, and only pay when they want downloads in full resolution.

💸 Monetization & Growth

Instead of subscriptions (which can scare away casual users), Vizbull runs on a credit-based model:
(NOTE: I am adding more Photo utilities so will change to small monthly subscription)

Basic: $9 (X credits)

This matches usage patterns better—some people only want 2–3 transformations, while others batch process 50.

For growth, I’m experimenting with:

🚀 Product Hunt launch (coming soon)

🎥 Short video marketing (TikTok & IG reels showing before/after transformations)

📰 Dev-friendly writeups like this one 😅

👀 What’s Next

Here’s what’s on the roadmap:

Batch uploads (drag & drop 10+ photos at once)

Custom prompt blending (combine your style notes with Vizbull presets)

Collage & GIF maker (before/after sliders, meme-style exports)

Integration with InfoCaptor AI (my other project—summarizer + knowledge graphs for YouTube transcripts) so users can connect visual creativity with research workflows.

Check out:

InfoCaptor AI
→ YouTube summaries + knowledge graphs.
https://my.infocaptor.com

Vizbull
→ AI photo-to-art generator.
https://vizbull.com

Wireframes.org
→ AI wireframe prototyper.
https://wireframes.org

How I Built My Own “Second Brain” With AI Tools (And Why You Might Need One Too)

Nilesh Jethwa — Mon, 25 Aug 2025 17:12:26 +0000

How I Built My Own “Second Brain” With AI Tools (And Why You Might Need One Too)

We live in a world where content never stops. YouTube adds over 500 hours of video every single minute.
As a developer, researcher, or founder, you know the feeling: you bookmark tutorials, watch half a conference talk, skim webinars… and later realize you don’t actually remember much of it.

That frustration led me to build InfoCaptor AI — a Chrome extension that turns YouTube into something more useful than passive video.
It’s basically a “second brain” for video content.

The Pain of Passive Learning

Here’s a familiar loop for most devs:

You watch a 90-minute AWS tutorial.

You nod along.

Two weeks later, you can’t recall the step-by-step process.

Or…

You binge startup talks on Y Combinator’s channel.

You feel inspired, but the insights scatter across your brain.

When you actually need them, you’re searching “that one Paul Graham talk” again.

The problem isn’t watching.
The problem is organizing and retrieving knowledge.

What InfoCaptor AI Does Differently

Instead of being “just another transcript tool,” InfoCaptor AI turns every video into structured artifacts you can actually use:

Transcript + Summary in Seconds

Entity Extraction (names, brands, concepts auto-tagged)

Word Clouds (spot patterns fast)

Knowledge Graphs (connect insights across videos)

That’s why I call it a visual second brain.

👉 Watch less. Recall more. Connect faster.
Free Chrome Extension : YouTube Transcript Summarizer
Use Cases for Developers & Makers

Students / Bootcamp Grads → Summarize long lectures, skip rewatching full videos before exams.

Researchers → Trace how a concept shows up across multiple talks.

Indie Hackers → Build connected playbooks from founder advice videos.

Working Professionals → Summarize webinars before a sprint planning or exec meeting.

Basically, if you rely on video to learn, InfoCaptor AI helps you compress time and expand recall.

But Learning Is Just Step One…

While building InfoCaptor AI, I realized people don’t just want to learn faster — they want to create faster too.

That’s why I ended up spinning off two sister projects:

Vizbull → AI for Creative Visuals

Takes any photo and transforms it into art styles:

Anime

Pop Art

Lego Figures

Barbie Poster

Line Sketch

Perfect for devs who:

Need quick profile pictures / avatars.

Want lightweight branding for a side project.

Run campaigns and need fresh visuals without hiring designers.

Wireframes.org → AI for Rapid Prototyping

If you’ve ever stared at a blank Figma file, you’ll get this.
Wireframes.org lets you:

Generate wireframes from a text prompt (“SaaS dashboard” or “lawyer website landing page”).

Drag and drop UI widgets.

Export mockups for feedback.

Super handy for devs validating ideas before investing in design polish.

Why I See This as an “Ecosystem”

For me, these aren’t random tools. They’re different angles on the same pain: time is scarce, context-switching is brutal, and creativity stalls when you’re stuck.

InfoCaptor AI → compress knowledge.

Vizbull → generate creativity.

Wireframes.org → unblock design.

Together, they give builders an edge:
you learn faster, create faster, and ship faster.

Closing Thoughts: Building a Second Brain That Works for You

If you’ve ever thought:

“I wish I could recall that video faster.”

“I need visuals but don’t have time for Photoshop.”

“I want to design, but the blank canvas is slowing me down.”

Then this stack was literally built for you.

Check out:

InfoCaptor AI
→ YouTube summaries + knowledge graphs.
https://my.infocaptor.com

Vizbull
→ AI photo-to-art generator.
https://vizbull.com

Wireframes.org
→ AI wireframe prototyper.
https://wireframes.org

They started as me scratching my own itch… but they might scratch yours too.

Visualize any website as Word Cloud

Nilesh Jethwa — Thu, 31 Oct 2024 14:46:56 +0000

SEO Pataka provides you with everything you need to perform a detailed SEO audit for any webpage you visit. With just a click, unlock all the key on-page elements, including:

● Title Analysis: View page titles, character counts, and word counts to ensure your titles are optimized for search engines and users.

● Heading Tag Details (H1 to H6): Analyze each heading tag on the page—from H1 to H6—and get insights on their usage, character length, and word count.

Advanced Keyword Extraction and Visualization

With advanced Natural Language Processing (NLP) techniques, this extension helps you extract key phrases and transform them into powerful visual insights.

● N-Gram Breakdown: Automatically extract keywords and break them into n-grams, including single-word keywords, two-word phrases, and beyond.

● Word Cloud Visuals: Turn keyword data into instantly understandable word clouds. SEO Pataka offers pre-defined shapes and color schemes to make your word clouds attractive and impactful.

● Easily visualize which keywords dominate your content.

● Bubble Pack Visualization: Take your keyword analysis further with our unique bubble pack visualization, presenting keywords as interactive bubble clusters for a fun, easy-to-understand representation.

Who Is SEO Pataka For?
● SEO Professionals: SEO Pataka helps you run quick and effective on-page SEO audits to help your clients rank higher.

● Digital Marketers: Gain powerful keyword insights and content structure details to optimize for both search engines and user experience.

● Website Owners: Empower yourself with data to better understand your site’s SEO and uncover ways to improve.

● Agencies: Use SEO Pataka as a powerful lead generation tool to impress potential clients with quick and insightful audits, showing them areas of improvement.

● Educators: Utilize SEO Pataka as an educational tool to teach students or trainees about SEO best practices, on-page optimization, and keyword analysis in a practical, hands-on manner.

SEOPataka's Free wordcloud generator can be used with any website. It scans the full page, breaks down the keyphrases and assigns the frequencies. It then instantly builds the word cloud right in front of your eyes, word by word!

It is a great tool to get instant insights.n-Page audit, Keyword Analysis, WordCloud
https://www.crawlspider.com/seo-pataka

DEV Community: Nilesh Jethwa

I Built a Simple AI Visibility Tracker in Python. Here’s What Breaks When You Scale It

The innocent-looking nested loop

You need a queue

Then brand in response breaks

The real product is history

Multiple models make things more interesting

Scheduling becomes a system of its own

AI responses aren't deterministic either

API cost isn't the only scaling problem

We had a useful head start

The interesting lesson

How I Built Vizbull: Turning Photos Into AI-Generated Art

How I Built My Own “Second Brain” With AI Tools (And Why You Might Need One Too)

Visualize any website as Word Cloud

Then `brand in response` breaks