DEV Community: Nikunj Maheshwari

Pomniter

Nikunj Maheshwari — Sun, 23 Aug 2026 19:09:48 +0000

Estimated reading time: 5 min

One small change since the last article: the project is no longer called Breadcrumb. I've renamed it to Pomniter, inspired by the Russian word помнить (pomnit), meaning "to remember"—which fits the core idea of the project much better.

Designing Pomniter: From Screenshots to Searchable Memories

In the first part of this series, I talked about a problem I kept noticing with screenshots.

We save them because we think they'll be useful later, but when we actually need them, we often have no idea where they are.

That led me to Pomniter.

I’ve also started putting the project together publicly. You can follow Pomniter project page, see what I’m building, and explore the current direction at https://pomniter.nikunjmaheshwari.in/

But identifying the problem is the easy part.

The harder question is: how do I actually build something that solves it?

I don't want Pomniter to be another gallery with a slightly better search bar. The idea is to make screenshots understandable enough that I can search for them the same way I remember them.

So before writing any code, I wanted to figure out what Pomniter actually needs to do.

What Should Happen When I Take a Screenshot?

At the simplest level, the flow should look something like this:

Screenshot
    ↓
Understand it
    ↓
Extract useful information
    ↓
Organize it
    ↓
Make it searchable
    ↓
Retrieve it when needed

I’m documenting the project and its progress on the https://pomniter.nikunjmaheshwari.in/ project page as I build it.

The important part here is understand.

If I take a screenshot of a LeetCode problem, I don't just want the system to know that the image contains the words "Binary Search."

I'd want it to understand that it's probably:

related to programming,
related to DSA,
specifically about binary search,
potentially useful for interview preparation,
and probably something I saved for future reference.

That's a very different problem from simply storing an image.

A Screenshot Contains More Than Text

One of the first things I realized while thinking about this project is that OCR alone isn't enough.

Consider a screenshot containing:

mid = left + (right - left) / 2

OCR can extract that text.

But the useful information isn't just the text.

It's the context around it.

It's a programming concept. It's related to binary search. It might be part of a coding interview note. It might be something I wanted to remember because I kept making overflow mistakes with the usual midpoint formula.

That context is what makes the screenshot useful later.

So Pomniter needs to look beyond the text and understand what the screenshot actually represents.

How Should I Search for Something I Saved?

This is probably the most important part of the project.

Let's say I saved a screenshot about BFS two months ago.

A traditional search might require me to type:

BFS

But that's not necessarily how I remember it.

I might remember:

"There was a screenshot with that BFS trick I wanted to revise before interviews."

Or:

"Find the graph algorithm note I saved a few weeks ago."

Or even:

"Show me the screenshot related to shortest path that I saved while studying graphs."

The system should be able to work with that kind of query.

That's why I'm interested in semantic search rather than relying only on filenames or exact keywords.

The goal isn't just to search for a word.

The goal is to search for what I remember.

The First Version of Pomniter

There are a lot of things I could try to build here.

Automatic reminders.

Duplicate detection.

Related screenshots.

AI-generated summaries.

Flashcards.

Actions from screenshots.

A conversational assistant.

All of these are interesting, but trying to build everything at once would probably be a mistake.

So I'm narrowing down the first version.

The core loop is:

Save a screenshot
        ↓
Pomniter understands it
        ↓
Pomniter stores what it learned
        ↓
I search using natural language
        ↓
Pomniter finds the relevant screenshot

If that basic loop doesn't work well, none of the other features really matter.

Where AI Comes In

This is where the project starts getting interesting technically.

My current idea is to use a combination of image understanding, OCR, embeddings, and retrieval-augmented generation.

At a high level, I'm thinking about something like:

                Screenshot
                    ↓
             Image Understanding
                    ↓
              Text + Context
                    ↓
            Structured Metadata
                    ↓
               Embeddings
                    ↓
             Semantic Search
                    ↓
              Relevant Results
                    ↓
                   RAG
                    ↓
             Natural Language
                 Response

This isn't the final architecture.

I expect this diagram to change once I start implementing and testing things.

There will probably be cases where OCR works better than I expected, cases where vision models are unnecessarily expensive, and cases where semantic search returns results that look relevant but aren't actually useful.

I want to discover those problems while building instead of assuming I already know the perfect solution.

But What About All the Other Features?

Once the core retrieval system works, Pomniter can become much more interesting.

For example, if the system understands what's inside a screenshot, it could eventually do things like:

Identify important information

"This looks like a flight ticket."

Recognize temporary information

"This looks like an OTP screenshot from three days ago."

Create reminders

"This screenshot contains an exam date."

Find related screenshots

"You have 6 other screenshots related to operating systems."

Summarize information

"This screenshot contains notes about TCP's three-way handshake."

Turn saved information into something useful

"Create flashcards from my screenshots about DBMS."

These are ideas for later.

For now, I want to get one thing right:

Can Pomniter actually help me find something I saved months ago?

What I Don't Want to Build

This is also something I need to be clear about.

I don't want Pomniter to become an app that tries to automatically organize every image on my device into hundreds of categories.

I don't want users to spend time maintaining folders, tags, and collections.

And I don't want another search box where users have to remember exactly what they typed when they saved something.

The whole point is to reduce the amount of remembering required from the user.

The system should do more of that work.

What's Next?

At this point, Pomniter is still just an idea backed by a rough technical direction.

I haven't tested the retrieval quality yet.

I don't know which models will work best.

I don't know how much processing should happen locally and how much should happen on a server.

I don't know how expensive it will be to process thousands of screenshots.

And I expect the architecture to change once I start building.

That's actually what I'm looking forward to.

The next step is no longer about defining the idea.

It's about building the first working version and finding out where the idea breaks.

Part 3 will be where I start building Pomniter.

In the meantime, you can follow the project, see what I’m building, and keep up with its progress at https://pomniter.nikunjmaheshwari.in/

The Problem with Screenshots Isn't Storage. It's Memory.

Nikunj Maheshwari — Wed, 05 Aug 2026 18:27:26 +0000

Estimated reading time: 4 min

Your Screenshots Aren't Memories. They're Forgotten.

Every day, we take screenshots.

A coding trick we might need later. A recipe someone shared. A travel itinerary. A tweet with an interesting opinion. A meme. An interview question. A reminder.

At that moment, every screenshot feels important.

So we save it.

And then... we almost never look at it again.

After a few months, our gallery contains hundreds or even thousands of screenshots. We know the information is somewhere, but finding it is often harder than searching the internet again.

That made me think about something.

The problem isn't that we take too many screenshots.

The problem is that we keep saving information, but almost never come back to it.

Why Existing Solutions Don't Really Solve It

Most gallery apps already provide folders, albums, search, and sometimes even OCR.

Those features are useful, but they still expect us to remember what we're looking for.

For example, suppose I remember saving a screenshot that explained a neat BFS trick.

I probably don't remember:

when I saved it,
what file name it has,
whether "BFS" even appears in the image,
or which folder it belongs to.

I only remember the idea.

Current search systems aren't designed for that kind of memory.

Screenshots Are More Than Images

When I looked through my own screenshots, I noticed they weren't random images.

They were things my past self thought were worth remembering.

Some contained programming notes.
Some were university notices.
Some were life hacks.
Some were recipes.
Some were reminders I forgot existed.

In other words, screenshots are becoming a personal knowledge base—but one that nobody can actually use efficiently.

What If Screenshots Behaved Like a Second Brain?

Instead of treating screenshots as images, what if we treated them as knowledge?

What if every screenshot could be understood instead of simply stored?

What if I could ask questions like:

"Show me the screenshot where I saved the BFS trick."
"Find that paneer recipe I saved a few months ago."
"What screenshots do I have about operating systems?"

Instead of searching by keywords, I would simply search by memory.

That idea eventually became a project I'm calling Breadcrumb.

The name comes from a simple thought: every screenshot is a breadcrumb your past self left behind, hoping your future self would find it again.

The Goal

I'm not trying to build another gallery app.

I'm trying to build a system that understands screenshots, organizes them automatically, retrieves them intelligently, and eventually turns them into something that's actually useful instead of forgotten.

This is going to be a long-term project, and I'll be documenting the entire journey—from the initial idea to the architecture, implementation, technical challenges, and everything I learn along the way.

This article is just the beginning.

The next article will focus on how I'm planning to design the system and why I think today's approach to screenshot search isn't enough.

If you've ever taken a screenshot thinking, "I'll definitely need this later," only to never find it again, I'd love to hear your experience.

I suspect I'm not the only one with this problem.

Follow the Journey

I'm documenting this project from idea to implementation. If you'd like to follow along, you can find me here:

GitHub – Source code and development progress

https://github.com/markstone111
LinkedIn – Project updates and milestones

https://www.linkedin.com/in/nikunjm111
Portfolio – Final case study and project showcase (coming soon)

https://nikunjmaheshwari.vercel.app

Building Breadcrumb
Part 1 — The Problem

📚 Should I Bunk?

Nikunj Maheshwari — Sun, 12 Oct 2025 21:39:35 +0000

An intelligent mobile app that helps students decide whether to skip class. It uses a machine learning model to provide a prediction based on factors like current attendance, professor's strictness, and upcoming tests.

✨ Features

AI-Powered Predictions: Uses a logistic regression model to give a "Bunk" or "Don't Bunk" recommendation.
Cross-Platform: Built with React Native (Expo), it runs on both iOS and Android from a single codebase.
Simple Interface: Clean and intuitive UI to quickly input data and get a result.
Deployable Backend: The Python Flask API is configured for easy deployment on Render.

GitHub