Where to go in Tunisia.

TL;DR

I built WhereToGoInTunisia, an AI-powered day trip planner for Tunisia that generates personalized itineraries in seconds. Started with ambitious Google Maps integration that hit me with a $467 surprise bill (107,773 API calls from just 12 test users, thanks to AI-generated code and 3am budget alerts I slept through). After negotiating it down to $40 with Google support, I pivoted to a manual plan creation MVP where users share their own day trips. Currently live at wheretogointunisia.com with 7+ governorate explore pages and SEO-optimized content.

The real lesson: sometimes "vibe coding" with AI assistants costs you $467, and Google's API documentation is as helpful as a chocolate teapot.

Why I Built This

My girlfriend and I are always exploring our country together, trying new restaurants, visiting museums, discovering cafés. But we had this frustrating pattern: we'd save spots on Instagram, bookmark places on Google Maps, screenshot recommendations from friends... and then we'd end up with these half assed days. Like, we'd plan one great restaurant for lunch but have no idea what to do before or after. Never a full day properly planned.

Friends kept asking us: "Where should we go for a romantic date?" or "What's a good spot for a group hangout?" We'd send them our saved places, but it was always scattered never a complete plan.

I thought: there should be an app where you just say "I have Saturday free in Sousse, mid-range budget, with my partner" and it spits out a perfect day. Breakfast spot -> beach time -> lunch -> café -> evening activity -> dinner. Done.

The technical motivation: I wanted to explore AI automation beyond chat interfaces. Could I make AI orchestrate a real-world experience using Google Maps data? That was the interesting challenge.

What I Was Trying to Solve

The core problem: Planning a complete, cohesive day in Tunisia requires stitching together scattered resources, and most people (including us) end up with incomplete plans or waste half the day figuring out "what's next?"

Who faces it:

• Couples like us trying to plan proper date days beyond just dinner
• Friend groups organizing outings who need suggestions that work for everyone
• Tunisian diaspora visiting home who've lost touch with what's new
• Tourists landing without local knowledge

Why existing solutions fail:

• Google Maps: Great for finding one place, useless for planning a sequence
• Instagram saves: Random spots with no structure or timing
• Travel blogs: Generic "top 10" lists without context for budget, timing, or preferences
• No one considers Tunisia-specific needs: halal options, prayer times, louage routes, TND pricing

I needed: "Give me 8 hours, TND 150 budget, with my girlfriend, we love coffee and culture" → get back an actual itinerary with timing, transport, and real places.

How I Actually Built It

The Initial Vision (And the $467 Lesson)

I went all-in on AI + Google Maps automation. Built a 4-step wizard collecting everything: city, date, time range, party type, transport, budget, activities.

The flow I envisioned:

1. User fills wizard → preferences collected
2. Hit Google Places API for matching venues
3. Calculate routes and timing between stops
4. GPT-4 generates natural itinerary narrative
5. Display on interactive map with timeline

Stack:

• Next.js 16 (App Router)
• Supabase (PostgreSQL + auth)
• Google Maps Places API + Directions API (the expensive mistake)
• OpenAI GPT-5-nano (itinerary narrative)

What I Built First

Got the wizard working, a clean 4 step flow:

1. What & Where: City, date, time range
2. When & Who: Party size/type, transport preference
3. Budget & Culture: Budget in TND, halal/alcohol/prayer preferences
4. Interests: Activities, ambience, special needs

Built comprehensive explore pages for 7 governorates (Tunis, Sousse, Djerba, Nabeul, Bizerte, Kairouan, Tozeur). Each with hero sections, top attractions, food guides, accommodation recommendations,full SEO content.

SEO optimized blog content covering Tunisia travel essentials - from hidden gems to practical travel tips. This content drives organic traffic while the manual plan builder gets finished.

Added legal pages early (Terms, Privacy, Cookie Policy) all Tunisia specific and GDPR compliant. Didn't want to launch sketchy.

Built the plan generation backend connecting Google Places API to OpenAI, calculating routes with the Directions API, generating human readable itineraries.

The $467 Wake-Up Call

Then Google sent me a bill for $467.20. 107,773 API calls from 12 test users.

I sat there staring at the email thinking "how the fuck?"

Now, I had set up budget alerts and cost caps in Google Cloud. But here's the thing about those alerts: they email you at 3am when you're dreaming about your next startup idea, and by the time you wake up, you've already blown through your budget. Google Maps API doesn't have hard limits where it just stops at your cap it keeps charging and sends you friendly little emails while you sleep.

And their documentation? Absolute garbage. Vague pricing examples, outdated cost calculators, buried information about what counts as a "basic" field vs. "premium" data. It's like they want you to accidentally rack up bills.

Here's what went wrong:

1. AI generated code with legacy API patterns I was "vibe coding" using AI assistants to help implement the Google Maps integration. The AI had outdated documentation references and used legacy API calls that were way more expensive than the new ones. I didn't catch it because I wasn't reading the API docs carefully myself (though to be fair, Google's docs are trash).

2. Wrong Places API tier Turns out I was using fields from the "premium" data tier without realizing it. Every place detail fetch was hitting the expensive endpoints.

3. Photos were killing me Every time someone viewed or refreshed a plan, I was fetching place photos fresh from Google. Photos are expensive, they were the bulk of my costs. And here's the kicker: Google's Terms of Service explicitly prohibit caching their photos or storing their data locally. You have to fetch them live every single time. It's a beautiful business model (for them).

4. Unrestricted API key initially My API key had no domain restrictions at first. When I finally dug into the logs, I found calls I couldn't even fully trace, possibly bots, possibly my own bugs causing loops.

5. Google's "generous" limits are a lie They give you a monthly free quota, but the moment you exceed it, the costs scale exponentially. No hard stops. Just emails at 3am and a bill at month's end.

I had to email Google support with a very apologetic explanation of my development error, showing I'd implemented proper restrictions, proving compliance with their ToS, and basically begging for mercy. To their credit, they were understanding and brought it down from $467 to $40. Still painful for an MVP with zero revenue, but better than rent money.

The Pivot & Cost Optimization

After that financial gut punch and several days of staring at Google's pricing documentation trying to make sense of it, I completely rethought the approach.

The realization: Why am I spending hundreds on API calls to generate mediocre algorithmic suggestions when real people (like my girlfriend and our friends) have actually tested amazing day plans?

New strategy: Social Itinerary Builder + Smart API Usage

Instead of AI generating plans from expensive Google data, let users manually create and share their proven day trips:

1. Manual plan creation - 4 step form:

   • "What & Where" (title, city, date)
   • "When & Who" (start/end time, party type)
   • "Add Stops" (restaurants, cafés, activities, user enters them manually)
   • "Review & Publish" (share or keep private)

2. Minimal, strategic Google Maps usage:

   • Autocomplete only for address suggestions when adding places
   • Basic place details (name, address) - avoiding premium fields
   • That's it. No photos, no constant refetching.

3. Mapbox for everything else:

   • Map display - Mapbox has a generous free tier (50,000 map loads/month vs Google's 28,000 for the same price)
   • Route calculation - Mapbox Directions API is way cheaper than Google's
   • Visual customization - Better looking maps anyway

A manually created plan using Mapbox for maps (free tier) and routing - showing exactly how we avoided the Google Maps cost trap. Users add stops, we handle the display without expensive API calls.

The cost difference is insane:

• Google Maps Static/Dynamic: Free up to 10,000 loads
• Mapbox: Free up to 50,000 loads
• Google Routes API: Free up to 10,000 requests/month
• Mapbox Directions API: Free up to 100,000 requests/month

4. User-generated database:

   • Each shared plan = 5-8 venue data points
   • User photos from real visits (not Google's restricted photos)
   • Tested sequences that actually work
   • Better than algorithmic picks

5. Social sharing as growth:

   • "Steal my perfect Sidi Bou Said date" as the hook
   • Share via WhatsApp/Instagram (huge in Tunisia)
   • Clone and customize others' plans
   • "I've been here" verification

User profiles with travel personality types and plan collections - the social layer that makes manual plan creation feel like sharing travel stories with friends.

Database Architecture

Simplified from 22 tables down to 13 core ones:

Core tables:

• itineraries - User created itineraries (45 columns covering timing, budget, cultural preferences)
• itinerary_stops - Individual stops in sequence with transport details
• places - The venue database (restaurants, cafés, activities)
• profiles - User accounts

Social features:

• itinerary_ratings, itinerary_favorites, itinerary_comments - Engagement
• itinerary_shares - Collaboration

Dropped: Complex monetization tables, analytics, features I wasn't using.

Important note: This isn't about caching API responses—it's about users creating the content directly. No caching needed because it's their input, not fetched data.

Technical Decisions

Mobile-first obsession: 90% of Tunisian users are mobile. Every interaction optimized for touch, thumb friendly zones.

Mapbox over Google Maps (post-pivot): For display and routing, Mapbox is way cheaper and looks better. Only use Google for place autocomplete when absolutely necessary.

SEO from day one: Schema.org markup, structured data, governorate specific meta tags. Blog content about Tunisian travel (Star Wars filming locations, traditional dishes, beach guides).

What I Learned & Would Do Different

The Hard Lessons

1. "Vibe coding" with AI assistants is dangerous for APIs. AI tools use outdated docs and you don't catch it unless you verify everything yourself. That $467 bill was mostly AI generated code I didn't audit properly.

2. Google's budget alerts are security theater. They email you at 3am. You're asleep. You wake up to $467 in charges. They don't have hard stops just "alerts" that are useless if you're not monitoring 24/7. Their ToS also prevents you from caching anything useful, forcing expensive refetches.

3. Read. The. Fucking. Docs. Even though Google's documentation is genuinely terrible (vague pricing, buried premium field lists, outdated examples), I should've spent more time understanding exactly what each API call cost before implementing. Ironically, I ended up using Google Gemini to help decode Google's own documentation since they're the same company, it actually understood the pricing structure way better than I did. This was especially helpful when optimizing for autocomplete and Places Details sessions. Sometimes you need AI to explain what the humans at Google couldn't explain clearly.

4. User generated content > Perfect AI suggestions. Real people's tested itineraries beat algorithmic recommendations. Should've started with the manual approach.

5. There are always cheaper alternatives. Mapbox was sitting there the whole time with a 10x better free tier for maps and routing. I defaulted to Google because it's familiar, not because it's best.

What I'd Change

Prototype with mock data first. Should've built the whole UI/UX with fake venue data, validated the concept, then connected expensive APIs.

Start with the social model. Should've validated that people will actually create and share plans before building complex AI generation.

Compare API pricing upfront. Should've made a spreadsheet: Google vs Mapbox vs alternatives for every feature. Would've caught the 10x cost difference immediately.

Better AI code review. When using AI assistants for API integration, double check every endpoint, every parameter, against the actual docs. AI loves to use deprecated expensive endpoints.

Hard stops, not alerts. Should've built my own middleware to count API calls and literally stop requests after a threshold. Can't trust Google's alerts.

Skills I Actually Leveled Up

• API cost modeling (the expensive way)
• AI code auditing (learning to not trust AI generated API calls)
• Strategic pivoting without abandoning the vision
• SEO for travel niche (content strategy, local search)
• Comparative API research (Mapbox vs Google, pricing models, ToS traps)

Where It Stands Now

Current status: Live at wheretogointunisia.com. Explore pages and blog content fully functional. Manual plan builder is 90% done, database wiring and social sharing features are in progress.

The landing page featuring Kairouan's Great Mosque - built before the $467 lesson taught me to pivot strategies

Why the pause: Validating the social sharing hypothesis before finishing. Running tests with local friends: will they actually create and share their day plans?

What's next:

• Finish the manual plan builder (2-4 weeks)
• Launch with target of 50 plans in first week
• If it works, add "Clone this plan" feature
• Eventually reintroduce AI as "enhance your plan" tool once the database is rich with real data

Using learnings elsewhere: Every project now starts with a cost calculator for any third party APIs. The "build social first, automate second" principle is shaping my other experiments. And I never trust AI generated API code without manual verification now. Also, I always check if there's a Mapbox equivalent before defaulting to Google.

Constraints & Tradeoffs

Can't fully escape Google Maps. For place autocomplete and basic venue data, Google is still best. But we minimize usage to just that. Decided this limited usage is worth it vs. fully manual entry.

Single-day focus only. Deliberately punted multi day trips to keep MVP manageable. Users keep requesting it, but it requires rethinking the entire data model.

No real-time availability. Would need restaurant booking integrations that don't exist in Tunisia. Showing general hours + user reviews instead.

Manual plan creation friction. Some users want instant AI plans. But manual creation builds better data and validates the social sharing model first.

Google's ToS restrictions. Can't cache their photos or data, which would've been the obvious optimization. Had to pivot entirely away from relying on their data.

The honest truth: WhereToGoInTunisia taught me that your first technical approach is often wrong, expensive third party APIs will punish sloppy implementation, budget alerts at 3am are useless, and sometimes the best products come from pivoting away from "clever AI automation" toward "simple social features that generate the data AI needs."

Also: always check if Mapbox can do it before paying Google 10x more. And never trust AI generated API integration code.

If you're building something in the travel space, want to chat about Tunisia, or need therapy after a surprise API bill, I'm @wassimbenr on LinkedIn or Twitter.