"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.

DEV Community: Ahitagni Saha