Skip to content
NatiBerkover

Israel Threat Map

The first product I built entirely through AI, without writing a single line of code.

Israel Threat Map is an interactive visualization of official travel warnings for Israeli travelers.

What started as a practical family problem became my first experiment in building a complete software product using AI coding agents.

Status
Live
Domain
Public data, geospatial visualization, AI-driven development
My role
Product vision, requirements, architecture decisions, quality assurance and release management
israelthreatmap.com
Israel Threat Map in Hebrew: a world map with countries colored by official travel-warning level, beside a legend with the number of countries at each level.
The notice shown before first use, in Hebrew: the information is for general purposes only and is not professional travel advice, the data is processed automatically and may contain errors, and official sources should be checked before traveling.Before first use
The live site, in Hebrew: countries colored by the official warning level. Inset: the notice every visitor acknowledges first.

01The spark

Planning our family vacation

Origin

  1. Our August family vacation
  2. Warnings that were hard to compare
  3. One map, colored by warning level
  4. My first AI-built product

My wife and I were planning our family vacation for August.

Following October 7 and the rise in antisemitism around the world, we were particularly concerned about choosing a destination where we'd feel comfortable traveling.

The Israeli government publishes travel warnings, but the information was presented in a way that made comparing and discovering destinations inconvenient.

We wanted something visual.

Rather than checking countries one by one, why not see the entire world on a map, with the warning levels represented by colors?

That would make it easy to identify countries with lower reported warning levels, including destinations we might not have considered otherwise.

I decided to build it.

But I had another motivation.

Despite my background as a software engineer, I hadn't written code professionally for almost a decade.

AI coding agents had become increasingly capable, and I wanted to test a simple hypothesis:

The hypothesisCould I build and publish a complete software product without writing a single line of code myself?

This became my first experiment in AI-driven development.

02The product

Making information easier to explore

Israel Threat Map takes official government travel-warning information and presents it on an interactive world map.

Countries are colored according to their reported warning levels, helping travelers explore destinations geographically instead of navigating a table.

The value isn't in creating new travel-safety assessments.

It's in making existing public information easier to understand.

This distinction matters.

A low warning level doesn't guarantee that a destination is safe, and an automatically maintained visualization can contain errors.

For that reason, visitors must acknowledge a warning before first using the service. It explains that the map may contain mistakes and that the official government website remains the authoritative source.

A permanent notice reinforces that limitation.

The map is an information-discovery tool, not an independent security assessment or real-time monitoring service.

Scope, stated plainly

What it is

  • Official travel-warning information on an interactive world map
  • A way to explore destinations geographically
  • An information-discovery tool

What it isn't

  • A new or independent security assessment
  • A real-time monitoring service
  • A replacement for the official website, which remains authoritative

03Decisions

Decisions that mattered

A map that omits countries isn't good enough

Dilemma
The recommended mapping library worked, but countries such as Mauritius were missing.
The call
Replace it with a library offering better geographic coverage.
Trade-off
Reworking a working implementation, because it didn't meet the requirement.

Claude Sonnet initially recommended a mapping library that appeared suitable for the project.

The first implementation worked, but something was missing.

Mauritius, for example, wasn't represented correctly. My child, who loves geography, identified several other missing countries.

The implementation technically worked, but the product didn't meet its requirements.

We replaced the library with a more capable alternative offering better geographic coverage.

This was one of my first lessons in AI-driven development.

AI can recommend and implement a technically valid solution that still fails the product's actual needs.

Recognizing that gap remains the responsibility of the person directing the work.

The official API wasn't always the best source

Dilemma
The government API and its published website sometimes disagreed.
The call
The published website takes precedence. The API is the fallback.
Trade-off
Screenshot extraction isn't perfect, but it addresses the observed inconsistencies.

I initially expected government data integration to be straightforward.

There was an API. Surely the obvious solution was to consume it.

But I discovered discrepancies between the API's information and what the government published on its website.

I decided that the published website should take precedence.

The data pipeline therefore extracts warning information from screenshots of the government website first. If that extraction fails, it falls back to the API.

Source precedence

  1. 1 · PreferredThe published website

    What travelers actually see, extracted from screenshots.

  2. 2 · FallbackIf extraction failsThe government API

    Used only when extraction fails.

This approach isn't perfect, but it addresses the inconsistencies I'd observed.

The important lesson was that the existence of a structured API doesn't automatically make it the most reliable representation of the information people actually see.

Don't automate something just because you can

Dilemma
The agent re-ran country-name mapping every day.
The call
Replace it with a manually invoked mapping process.
Trade-off
A small manual step, matched to how rarely country names change.

Another challenge was matching Hebrew country names from the government data with the English-language identifiers used by the geographic visualization.

Some mappings were surprisingly difficult.

The agent initially introduced a process that repeated country-name mapping every day.

I challenged that decision.

Countries and their names don't change frequently enough to justify continuously repeating that work.

We replaced it with a manually invoked mapping process.

A small architectural decision, but a useful reminder: automation should respond to the nature of the problem, not become an objective of its own.

04Under the hood

A small application with real data challenges

The application combines government information, data extraction, country-name normalization and geographic visualization.

It uses the government's published website as its preferred information source, with API fallback when extraction fails.

The data path

  1. ScheduledProcessing run

    The data is processed on a scheduled basis.

  2. SourceWebsite, then API

    Published website first, API when extraction fails.

  3. NormalizeCountry identities

    Hebrew source names matched to geographic identifiers.

  4. PresentInteractive map

    With its limitations visible to users.

Simplified. Name mapping is maintained by a manually invoked process, not on every run.

The data is processed on a scheduled basis and mapped to the corresponding countries in the visualization.

Some of the hardest work involved normalizing country identities between Hebrew source information and geographic datasets.

The application also needs to distinguish data freshness from absolute accuracy.

My working assumption is that, when the government hasn't changed its published recommendations, the map shouldn't invent updates of its own.

But automated processing has limitations, and the service makes those limitations visible to users.

The goal is to offer a convenient view of official information without pretending to have greater authority than the original source.

05Building with AI

My first experiment

I built Israel Threat Map using Claude Code and Sonnet, starting with a $20-per-month subscription.

I didn't personally write any code.

  • Claude Code and Sonnet
  • $20-per-month subscription to start
  • About a week and a half to build
  • No code written by me

The application itself took approximately a week and a half to build.

I directed the requirements, evaluated the product, challenged technical decisions and worked with the agent to resolve problems.

Who did what

MeJudgment

  • Requirements
  • Evaluating the product
  • Challenging technical decisions
  • Release management

SharedTogether

  • Resolving problems

AI agentsExecution

  • All of the code

The experience was eye-opening.

I discovered that AI could implement a working application much faster than I expected, even after I'd spent years away from hands-on software development.

But I also learned that AI's technical confidence shouldn't be confused with product correctness.

The initial map-library choice and unnecessary recurring country-mapping process were both examples of decisions I needed to challenge.

The surprise came after the application worked

After I shared the site, a friend asked a question I hadn't considered:

“What about accessibility?”

I quickly discovered how much work could be involved in making a public website meet accessibility and related legal requirements.

I spent roughly another two weeks addressing those concerns, more time than I'd spent building the application's core functionality.

Where the time went

  • Building the applicationAbout a week and a half

  • Accessibility and legal requirementsRoughly another two weeks

Approximate, from the durations in the text.

It was frustrating at the time.

But it was also an essential lesson.

Building software that works is only part of building software that's ready for public use.

That experience influenced the way I approached every subsequent project.

06Status

A successful experiment

Israel Threat Map is publicly available.

My LinkedIn launch post received approximately 500 likes and considerable exposure. The site gained visibility in search results and has continued receiving organic search traffic.

≈500likes on my LinkedIn launch post, with considerable exposure

  • Visibility in search results
  • Continuing organic search traffic
  • My name and LinkedIn profile linked from the product

My name and LinkedIn profile are linked from the product, making it another way for people to discover my work.

Those are useful outcomes, but the most important results were personal and professional.

I proved to myself that I could build an entire software product through AI agents without writing the implementation myself.

I developed my first practical understanding of AI-driven engineering.

And I learned about the substantial responsibilities that come with operating a public website.

The product gave me both a useful public service and the foundation for a new way of working.

07Reflections

The right experiment should have the right risk profile

Looking back, I wouldn't necessarily choose the same project if I were starting my AI-building journey today.

Travel-safety information is consequential.

Even with official sources, automated updates and clear disclaimers, errors could affect people's decisions.

For an experiment primarily intended to develop my AI-building capabilities, a lower-risk product such as ClearClass could achieve many of the same learning objectives.

  1. ClearClass

    a lower-risk product

  2. Israel Threat Map

    travel-safety information

Lower consequence of errorHigher consequence of error

Same learning objectives, different cost of a mistake.

That doesn't diminish the value of what I built.

Israel Threat Map was my first step into AI-driven software development. It showed me what was possible, exposed the limitations and gave me the confidence to tackle increasingly complex projects.

It also taught me to consider the consequences of getting something wrong before deciding which problem to solve.

The bigger lesson is that AI can remove much of the friction of implementation, but it doesn't remove the responsibility for the product you release.

Keep exploring

I work with leadership teams on AI transformation, product and data strategy, and building the capabilities to deliver it. Let's talk

Next case study

ClearClass

The lower-risk kind of experiment I'd choose today.