7-Day Micro-App: Restaurant Recommender with Claude

Tactical 7-day plan to build a micro-app that recommends restaurants using Claude, ChatGPT, and maps — for non‑devs and devs alike.

Stop arguing in the group chat — build a tiny app that solves decision fatigue in 7 days

Decision fatigue is real: friends, coworkers, and family spend more time arguing about where to eat than actually eating. The good news in 2026: with Claude and ChatGPT plus no-code tools or a tiny codebase, you can ship a micro-app that recommends restaurants tailored to your group in one week. This guide gives a tactical, day-by-day plan so non‑devs and developers alike can replicate the dining app case study end-to-end — data model, prompts, UI, maps integrations, and deployment.

Why build a micro-app now (2026 context)

Late 2025 and early 2026 accelerated two trends that make this week-long build realistic:

LLM tool-use maturity: Both Anthropic (Claude) and OpenAI (ChatGPT families) solidified tool-use APIs and retrieval-augmented generation (RAG) patterns, making it safe and cheap to combine real-time data with LLM reasoning.
No-code + composable infra: Airtable, Glide, Softr, and platforms like Supabase blur the line between prototyping and production. Map APIs and connector platforms (Make, Zapier) improved reusable templates for location-aware apps.

Those shifts mean you can build a useful, private micro-app that serves a handful of users without a big engineering team.

What you'll ship in 7 days (MVP)

A responsive web micro-app: user can create/join a group, set preferences (diet, budget, cuisine), and get 3 ranked restaurant recommendations.
Back-end logic to fetch candidates from a map provider (Google Places / Mapbox / HERE), re-rank with an LLM (Claude or ChatGPT), and display map + directions.
Optional features: votes, short reviews, and a shareable link or TestFlight beta for friends.

Two recommended implementation paths

Pick one based on your comfort level:

No-code / low-code (fastest for non-devs): Airtable as a database, Glide or Softr for UI, Make/Zapier for orchestration, Maps via Mapbox/Google Maps plugin, and call ChatGPT/Claude via webhook. Delivery: publishable in 2–4 days.
Minimal code (flexible and repeatable): Frontend in a static site builder (Glitch/Next.js/Vite), backend serverless functions (Vercel / Netlify), Supabase for DB/auth, map integration via Mapbox or Google Maps APIs, LLMs via Anthropic/OpenAI SDKs. Delivery: 7 days with iterative testing.

Core data model (single page of truth)

Keep the model minimal. You’ll expand organically based on usage.

Entities

User: id, name, email (optional), avatar, dietary tags
Group: id, name, members[], center_location (lat,lng), radius_meters
Preference: user_id, cuisine_tags, price_level (1-4), max_distance_m, openness_score (0-1)
Restaurant: place_id, name, lat, lng, cuisine_tags, price_level, rating, source (Google/Mapbox/HERE), raw_metadata
Session: group_id, timestamp, candidates[], selected_restaurant_id

JSON schema example

{
  "restaurant": {
    "place_id": "ChIJ...",
    "name": "La Taqueria",
    "lat": 37.776,
    "lng": -122.424,
    "cuisine_tags": ["mexican","tacos"],
    "price_level": 2,
    "rating": 4.6
  }
}

Day‑by‑day plan: build, test, ship

Below is a compact schedule that non‑devs can follow. Each day has a clear deliverable.

Day 1 — Define scope, pick stack, and design data model

Deliverable: App spec one-pager + chosen stack (no-code or minimal code).
Action steps:
1. Write a one-paragraph user story: e.g., "I want to pick 3 restaurants for my group of 4 with dietary restrictions and a 2-mile radius."
2. Pick tools: Airtable + Glide for non-devs, or Supabase + Vercel + Mapbox for coders.
3. Create the data model (use the JSON above). If using Airtable, create base with tables: Users, Groups, Restaurants, Sessions.

Day 2 — Wireframe UI and prototype flows

Deliverable: Clickable prototype (Glide / Figma / Softr).
Action steps:
1. Sketch main screens: Landing, Create/Join Group, Member Preferences, Recommendations, Map & Details.
2. Using Glide or Softr, map your Airtable columns to UI elements and build the flows for creating a group and entering preferences.
3. Focus on microcopy: prompts for preferences and why you need location permission.

Day 3 — Connect Maps and fetch candidates

Deliverable: Working candidate fetch (list of restaurants near the group center).
Action steps:
1. Choose a map provider: Google Places (best coverage), Mapbox (flexible pricing & vector maps), or HERE (enterprise options). For most micro-apps, Mapbox or Google Places are simplest.
2. If no-code: use a Map/Places plugin in Glide or a Make/Zapier connector to pull places into your Airtable Restaurants table.
3. If minimal-code: implement a serverless function that calls the Places API with the group's center and radius, saves the top 20 candidates into Restaurant table. Example pseudo-request:
```
// fetch candidates
fetch('https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=37.776,-122.424&radius=3000&type=restaurant&key=YOUR_KEY')
```

Day 4 — Build the ranking brain with Claude or ChatGPT

Deliverable: LLM-based re-ranking that returns 3 tailored suggestions.
Action steps:
1. Decide runtime: call the LLM directly from your orchestration (Make webhook, serverless function) after fetching candidates.
2. Use RAG: provide the LLM with structured candidate metadata (JSON) and group preferences so it re-ranks instead of hallucinating contact info. See techniques from multimodal media workflows for handling structured context and attachments.
3. Implement a system message + few-shot examples to lock behavior. Use temperature low (0.0–0.2) for deterministic rankings.

Sample system & user prompt (starter)

// System instruction
"You are a concise restaurant recommender. Given group preferences and a list of candidate restaurants (JSON), return the top 3 ranked choices with a 1-line reason each and one quick route (walking/drive minutes). Avoid inventing facts. If info is missing, be explicit."

// User payload (trimmed JSON)
{
  "group": {"members":[{"name":"Ava","diet":"vegetarian"}], "center": [37.776,-122.424], "radius_m": 3000},
  "candidates": [{"name":"La Taqueria","cuisine_tags":["mexican"],"price_level":2,"rating":4.6,"distance_m":800}, ...]
}

Claude vs ChatGPT prompts notes

Claude tends to be crisp with step-by-step reasoning. Use explicit tool/metadata instructions and request a JSON-only reply for easy parsing. Also consider secure-agent patterns described in secure desktop AI agent policy when designing credentials and local tooling.
ChatGPT (OpenAI) is great for creative framing and can use the Responses API to attach tools. Also request JSON-only output and a strict schema to avoid parsing errors.

Day 5 — UI integration, maps embedding, & directions

Deliverable: Recommendations show on a map with quick navigation links.
Action steps:
1. Embed a map view (Mapbox GL JS or Google Maps JS) showing the 3 recommended places and the group center.
2. Provide deep links: Google Maps directions URL or Apple Maps link so users can open navigation on their phones.
```
// Example Google Maps directions link
https://www.google.com/maps/dir/?api=1&origin=37.776,-122.424&destination=37.772,-122.414&travelmode=walking
```
3. Show a compact detail card: name, cuisine tags, price, rating, 1-line reason from the LLM, and a "Navigate" button.

Day 6 — Testing, feedback, privacy & cost tuning

Deliverable: Internal beta with 3–10 testers and tuned prompt + rate limits.
Action steps:
1. Run test sessions with different preference combinations (vegan, group with mixed budgets, strict distance limits) to discover edge cases.
2. Adjust LLM prompt if the model hallucinates details — add stricter instruction to rely only on provided metadata.
3. Estimate costs: Places API calls, LLM tokens, hosting. Add basic throttling: cache restaurant results for 6–24 hours to reduce calls and cost. For serious scale or analytics you can swap ad-hoc caches for robust stores or OLAP patterns like those in ClickHouse for scraped data to keep query costs down.
4. Document privacy: keep location scoped to group center, do not persist precise member locations unless users opt in. For public sharing, scrub PII.

Day 7 — Deploy, monitor, and invite friends

Deliverable: Public link or private beta live, usage analytics, and simple plan for next features.
Action steps:
1. Deploy your frontend (Glide publish or Vercel deploy). If using Vercel, push to GitHub and set env vars for API keys. For serverless patterns and scheduling, see serverless scheduling best-practices in Calendar Data Ops.
2. Add lightweight analytics: Plausible or a simple Airtable view counting sessions. Capture which recommendation was selected to improve prompts.
3. Invite your inner circle, collect qualitative feedback, and iterate on prompts and UI microcopy. If you rely on partner map providers or connectors, reduce onboarding friction with AI-powered flows discussed in reducing partner onboarding friction.

Practical prompts and parsing patterns

Always ask the LLM to return structured JSON so your UI can render reliably. Below is a production-ready final prompt you can paste into Anthropic/OpenAI calls.

// Final prompt outline
SYSTEM: You are an objective recommender. Only use the provided candidate metadata. Respond with exactly one JSON object. Do not add extra commentary.

USER: Return top 3 restaurants ranked for the group. Input:
{ "group": {...}, "candidates": [...] }

Return format:
{
  "recommendations": [
    {"rank":1, "place_id":"...", "reason":"1-line reason", "eta_minutes":8}
  ]
}

Minimal serverless example (pseudo-code)

Here's a compact Node.js serverless handler pattern that fetches places, calls the LLM to rank them, and returns the top 3. Replace placeholders with your keys.

import fetch from 'node-fetch';

export default async function handler(req, res) {
  const { lat, lng, radius, prefs } = req.body;

  // 1) Fetch candidates (Places)
  const placesResp = await fetch(`https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=${lat},${lng}&radius=${radius}&type=restaurant&key=${process.env.GOOGLE_KEY}`);
  const places = (await placesResp.json()).results.slice(0, 20);

  // 2) Build LLM payload
  const llmPayload = {
    system: 'You are a JSON-only restaurant recommender...',
    input: { group: { prefs }, candidates: places.map(p => ({ id: p.place_id, name: p.name, rating: p.rating, price_level: p.price_level, distance_m: computeDistance(p.geometry.location, {lat, lng}) })) }
  };

  // 3) Call Claude or ChatGPT
  const llmResp = await fetch('https://api.your-llm.com/v1/respond', {
    method: 'POST', headers: { 'Authorization': `Bearer ${process.env.LLM_KEY}`, 'Content-Type':'application/json' }, body: JSON.stringify(llmPayload)
  });
  const llmJson = await llmResp.json();

  // 4) Parse & return
  res.json({ recommendations: llmJson.recommendations });
}

Cost, rate limiting, and privacy considerations

Cost: Cache Places results for 6–24 hours. Use LLMs sparingly — re-rank on demand or batch requests. Track usage to avoid surprise invoices.
Rate limiting: Add exponential backoff for Places and LLM calls. For public share links, require a join code to keep app micro (few users).
Privacy: Minimize location retention. If you store member locations, encrypt at rest and explain retention to testers. For GDPR-style audits, provide a data deletion endpoint (Airtable + Glide support record deletion).

UX tips that make the micro-app delightful

Show a quick “Why this?” line (generated by the LLM) — it reduces friction when people disagree.
Provide an instant shuffle button (“Re-vibe”) that re-runs the ranking with a different temperature or emphasis (e.g., “prioritize budget” or “prioritize rating”).
Add micro-animations to map pins and a compact summary card for each recommendation to keep screens scannable.

Scaling beyond the micro-app

If the idea takes off, here are sensible next steps:

Replace ad-hoc cache with a Redis layer for hot queries. For edge and micro-region tradeoffs, see micro-regions & the new economics of edge-first hosting.
Use RAG to attach recent user reviews and your own shortnotes about places for better context.
Implement A/B testing for prompt variants: does “friendly” vs “concise” reasoning lead to higher selection rates?
Consider multi-LLM ensemble: use Claude for deterministic filtering and ChatGPT for copywriting reasons to present to users. Multi-model orchestration patterns are discussed in AI training & orchestration.

What to expect — and common pitfalls

LLM hallucinations: avoid by sending structured metadata and requiring JSON-only responses.
API quotas: map providers throttle free tiers — plan for caching and restrict candidate radius to reduce calls. If you need offline-first behavior or free nodes for field apps, check deploying offline-first field apps on free edge nodes.
User input quality: normalize cuisine tags (e.g., convert "Italian" and "italian" to same tag) so the LLM gets consistent signals.

"Vibe-coding" micro-apps are a new way to solve small, personal problems quickly. A focused one-week build is empowering — and practical — when you pair LLMs with the right scaffolding.

2026 trends to watch (how this app fits the future)

Model tool-use increases: Expect richer tool integrations (calendar, ticketing, ride-hail) to let recommenders not just suggest but book reservations and rides.
Edge LLMs reduce cost: Local LLM inference options may let you run light personalization on-device for privacy-conscious groups.
Composability rules: More ready-made connectors and templates will make 1-week micro-apps even faster — but effective prompting and UX are still the differentiator.

Actionable takeaways (start now)

Choose your path: no-code (Airtable + Glide) for fastest ship, minimal code (Supabase + Vercel) for control.
Set up your map provider and LLM API keys today — these are the slowest approvals.
Write and test one strict JSON prompt that the LLM must follow; iterate with real group data on Day 6.

Resources & checklist

Airtable base template: Users, Groups, Restaurants, Sessions
Map provider trial: Google Cloud Console / Mapbox account
Anthropic / OpenAI account & API keys
Deployment: Glide publish or Vercel (connect GitHub + env vars)

Final thoughts

Building a micro-app to recommend restaurants is an ideal first project in 2026: it’s personally useful, bounded in scope, and perfectly illustrates how Claude and ChatGPT can add real-world utility without requiring a large engineering team. By following this tactical, 7‑day plan you’ll have a working MVP that can be refined into a delightful product or remain a private, high-utility tool for your circle.

Call to action

Ready to ship? Pick your stack and start Day 1 now. If you want a ready-made starter kit (Airtable + Glide + LLM prompt templates + deployable serverless code), click to download the 7‑Day boilerplate and a collection of production prompts tuned for Claude and ChatGPT.