DEV Community: Ahitagni Saha

🌱 I Built ESCAPE: Touch Grass to Unlock Social Media — Powered by Offline AI

Ahitagni Saha — Sat, 10 Oct 2026 20:18:25 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

What if the password to YouTube wasn't a PIN, but a little adventure outside?

Meet ESCAPE — The World Is Your Password 🌱

I built an experimental Android app for people who find themselves endlessly scrolling. Instead of showing another screen-time chart, ESCAPE encourages you to get outside, walk, touch grass, and rediscover nature.

The idea is simple: the real world becomes your password!

Every outdoor quest has three steps:

Move 🚶 — Step outside and complete a walking goal using your phone's step sensor and timer.
Discover 🌳 — Find something interesting in nature: grass, a beautiful tree, flowers, or a reflection in water.
Capture 📸 — Photograph your discovery, preview the image, and tap Analyze. ESCAPE checks the evidence locally.

Complete the quest and earn a limited window of social-media access!

But why stop at walking?

On weekends, ESCAPE also encourages bicycle adventures and helps discover nearby parks, greenery, and cycling paths.

Before 6 PM, adventures focus on outdoor activities. After 6 PM, users can choose between an outdoor adventure and an indoor nature-inspired challenge. An activity already in progress continues without being reset.

Demo

🎬 Watch ESCAPE in action

▶ Watch the real Android demo on YouTube

The video demonstrates the ESCAPE experience on a real Android phone: blocking YouTube, tracking a walking quest, capturing and previewing a nature photograph, and approving the evidence.

Here's what excited me most: I tested image analysis with my phone disconnected from the internet, and ESCAPE still approved the nature photograph!

The recording shows the approval result, although it doesn't independently show the network being disconnected. The demonstration uses accelerated Demo Mode to shorten the walking requirement.

🌐 Visit the ESCAPE project showcase

Code

💻 ESCAPE — GitHub Repository

ESCAPE is an open-source Android prototype built using Flutter and Kotlin. The source code is available publicly, although the app hasn't been published to Google Play yet.

How I Built It

ESCAPE combines open-weight AI with Android's native capabilities:

Gemma 3 1B IT + LiteRT-LM: Generates creative nature-based missions locally on the phone. Missions are cached to avoid repeatedly running the model for notifications.
Flutter + Kotlin: Provides the user interface, app monitoring, blocking overlay, and mission management.
Android sensors: Tracks walking time, steps, and optional GPS-based cycling progress.
Google ML Kit: Analyzes captured photographs entirely on-device, checking broad nature subjects such as trees, plants, and water.
OpenStreetMap/Overpass: Discovers nearby parks and cycling infrastructure when internet is available, with cached results for later offline use.

One important distinction: Gemma 3 1B is a text model. It generates creative missions, while ML Kit handles image recognition.

I also separated creativity from validation:

AI creates the adventure. Android tracks the progress. Local image recognition evaluates the evidence.

That keeps the unlock rules predictable even when AI responses vary.

Why Does Open Innovation Matter?

Imagine walking through a park without mobile data. Should an AI-powered outdoor companion stop working?

I don't think so.

Using open-weight Gemma with on-device inference allows ESCAPE to create new mission ideas without constantly contacting a cloud API. Photo analysis also happens locally, without uploading pictures to a server.

After the initial setup, the core adventure experience can work offline. Downloading the model and discovering new nearby locations still require internet connectivity.

For me, the most interesting part is the irony:

I built an AI application whose ultimate goal is to make people spend less time on their phones.

Sometimes the best use of technology is encouraging us to experience something beyond technology.

My Agent Session

I used GitHub Copilot CLI during development to inspect mission verification and reward rules, improve test coverage, and add automated Flutter validation.

I didn't capture a DevRelay agent-session embed, but here's evidence of the Copilot CLI development work:

You can also inspect the GitHub Actions workflow.

Prize Categories

Best Use of Gemma

Gemma 3 1B runs locally through LiteRT-LM, generating creative outdoor missions without requiring continuous internet connectivity.

Best Use of GitHub Copilot

GitHub Copilot CLI helped improve the project's reliability through testing and CI workflow development.

ESCAPE — Less scrolling. More strolling. Go touch grass! 🌿

"Can I ignore this?" — I built Handle It NL for a friend navigating Dutch letters

Ahitagni Saha — Sun, 04 Oct 2026 18:30:42 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built Handle It NL, an AI assistant that helps expats understand Dutch administrative letters and figure out what they actually need to do.

I originally built it for my wife. She recently moved to the Netherlands and is learning Dutch, but official letters from municipalities and government organisations can still be difficult to understand.

The problem is that translation is only half the job.

Even after translating a letter, you can still be left asking:

“Okay... but what am I supposed to do?”

Is it serious?

Can I ignore it?

Is there a payment?

What is the deadline?

Do I need to visit somewhere?

What should I bring?

That became the idea behind Handle It NL.

A user uploads a photo, screenshot, or scanned PDF and the app explains:

WHAT IS THIS?

CAN I IGNORE IT?

WHAT DO I NEED TO DO?

BY WHEN?

It classifies letters as:

Payment required
Appointment / visit
Action required
Information only
Mixed
Needs review

It can also extract deadlines, payment information, appointment details, things to bring, and important Dutch terms.

When useful, the AI can call tools to:

verify a Dutch address through PDOK;
prepare an .ics calendar event;
generate a Google Calendar link;
save a deadline or appointment;
look up selected Dutch process guidance.

The important rule behind the application is:

The model interprets. Deterministic tools execute.

The model can decide that an address should be checked, but PDOK performs the verification.

The model can identify an appointment, but Python creates the actual calendar file and SQLite confirms whether the deadline was saved.

I also added safeguards after discovering that the same PDF could sometimes produce slightly different AI wording.

Appointments are now deduplicated using:

date/time + physical location

and uploaded files are hashed with SHA-256.

So uploading the exact same document again reuses the stored analysis instead of generating another potentially inconsistent interpretation.

If the AI cannot produce a reliable structured result, the app shows:

MANUAL REVIEW NEEDED

instead of incorrectly suggesting that no action is necessary.

Demo

Live Demo

👉 https://nl-expat-copilot-1.onrender.com

The demo uses synthetic Dutch administrative letters rather than real personal correspondence.

Example: municipality appointment

For a Burgerzaken appointment letter, Handle It NL can:

explain the letter in plain English;
identify the appointment time;
list what the user should bring;
verify the address through PDOK;
prepare a calendar event;
save the appointment.

Saved deadlines

Important appointments and deadlines appear in a dashboard and can be reopened later with the full explanation.

The app also handles the opposite case.

If a letter is purely informational, it can return:

INFORMATION ONLY
NO ACTION NEEDED

without creating unnecessary deadlines or calendar events.

What my wife thought

When I showed the application to my wife, what surprised her most was that it felt more useful than a normal translation tool.

A translator can explain what a Dutch sentence says, but Handle It NL also tries to explain how important the letter is, whether action is required, what the deadline is, and what she should do next.

That extra context was what stood out to her.

Code

GitHub:

👉 https://github.com/Ahitagni07/nl-expat-copilot

Main stack:

Frontend: Angular 22
Backend: FastAPI
AI: DeepSeek V4.1 Flash via OpenRouter
PDF processing: PyMuPDF
Storage: SQLite
Address verification: PDOK
Hosting: Render

How I Built It

The architecture is:

       Dutch letter / scanned PDF
                  │
                  ▼
               Angular
                  │
                  ▼
               FastAPI
                  │
                  ▼
              OpenRouter
                  │
                  ▼
        DeepSeek V4.1 Flash
                  │
          decides what it needs
                  │
       ┌──────────┼──────────┐
       ▼          ▼          ▼
     PDOK      Calendar    SQLite
       │                     │
       └──────────┬──────────┘
                  ▼
          Actionable result

Multimodal document analysis

FastAPI accepts images and scanned PDFs.

For PDFs, PyMuPDF renders the first few pages into optimized images before sending them to the multimodal model.

The model handles:

document understanding;
classification;
structured extraction;
deciding whether a tool is useful.

Tool calling

The available tools include:

lookup_official_process()
verify_dutch_address()
prepare_calendar_event()
save_deadline()
get_upcoming_deadlines()

A typical appointment flow looks like:

model reads document
        ↓
verify_dutch_address()
        ↓
PDOK verifies location
        ↓
prepare_calendar_event()
        ↓
Python creates .ics
        ↓
save_deadline()
        ↓
SQLite confirms saved/already exists
        ↓
final explanation

The frontend shows these actions as an Agent Trace, so the user can see which real tools were used.

Safety

Handle It NL never performs payments.

For payment letters it may extract an amount, deadline, or reference, but the user is told to verify payment details against the original document or official portal.

Calendar events are also never silently added. The app creates an .ics file or pre-filled calendar link and leaves the final action to the user.

Why Does Open Innovation Matter?

Handle It NL uses DeepSeek V4.1 Flash, an open-weight multimodal model, through OpenRouter.

I use hosted inference for this demo because running a model of this size locally on my laptop is not practical.

But the application is not designed around one closed model provider.

The model is responsible for:

understand
extract
classify
choose a tool

while normal application code handles:

address verification
deadline storage
duplicate detection
calendar generation
structured validation
safety rules

That separation means the inference layer could later move from OpenRouter to self-hosted or local open-weight inference without rewriting the entire application.

This is especially useful for an application dealing with personal correspondence, where privacy, data residency, cost, and model choice may matter.

The current public demo is not fully local, so I use synthetic documents and make that trade-off explicit.

For me, open innovation matters because it keeps the intelligence layer replaceable while the application continues to own its behaviour.

Prize Categories

Best Use of Render

I am entering Best Use of Render.

The public demo runs entirely on Render:

Angular is hosted as a Render Static Site;
FastAPI runs as a Render Web Service.

Render rewrite rules route frontend /api/* requests to the FastAPI backend, allowing the same Angular API paths to work locally and in production.

👉 https://nl-expat-copilot-1.onrender.com

What I Learned

The most interesting problems were not about calling an AI model.

They were about deciding when not to trust it.

During the weekend I had to solve issues such as:

duplicate appointments;
inconsistent wording from the same document;
structured-output failures;
address verification;
avoiding false “No action needed” results.

Each of those problems moved more responsibility from the model into deterministic application code.

That ultimately made Handle It NL much more useful.

Final Thought

Handle It NL started with one simple question:

Translation can tell someone what a Dutch letter says. But who tells them what they should actually do next?

That is the problem I wanted to solve.