I'm obsessed with what I call "nano apps"—highly personalized tools you build in 30 minutes to an hour, just for you. Your own workout tracker. Your own search tool. Something that solves your problem, even if it's useless to everyone else.

Last week, I built one for checking sauna availability.

The Piedmont Springs booking site is a special kind of hell. Six clicks minimum just to see if a single service has openings:

1. Go to the site
2. Click "Online Booking"
3. Wait for the widget, click "Book"
4. Select category (Sauna)
5. Select service (45 Minute Sauna)
6. Finally see the calendar

Six clicks. For one service.

I care about six services—different sauna durations, steam rooms, hot tub, combination room. To check them all? 36 clicks. Three minutes of clicking. Every single time I want to see what's available.

This is ridiculous.

So I built a tool that shows everything in one view. One command, five seconds, all six services with direct booking links.

Here's how it happened.

reverse engineering the api

I used reverse-api-engineer—a CLI tool that records network traffic while you browse. Set it up, launched it in manual mode, clicked through the booking flow, and watched the API calls stream by.

The site uses Booker.com (now Mindbody) as its backend. Three endpoints do all the work:

• /menu/sections — lists all services
• /availability/availabledates — shows which dates have openings
• /availability/availability — returns specific time slots

The tricky part? Authentication. The API needs an OAuth token, and the OAuth flow is messy.

So I did something simpler: use Playwright to load the booking page headlessly, intercept the network requests, and grab the access_token from whatever the page requests. Let the browser do the OAuth dance, then steal its token.

def _obtain_token_via_playwright(self):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()

        def handle_request(request):
            if "access_token=" in request.url:
                match = re.search(r'access_token=([^&]+)', request.url)
                if match:
                    self.token = match.group(1)

        page.on("request", handle_request)
        page.goto(BOOKING_URL)
        # Token captured automatically!

From there, building the client was straightforward. Fetch services, filter to the ones I care about, get dates, get slots, aggregate everything.

Then I built a simple HTML dashboard that groups services by priority—one-hour sessions first, then 45-minute, then 30-minute. Each date is clickable and takes you straight to the booking page.

The hardest part was getting the booking URL format right. Took a few iterations, but eventually I had the pattern:

https://go.booker.com/location/PiedmontSprings/service/{service_id}/{service_name}/availability/{date}/any-provider

the results

Before: 36 clicks, 3+ minutes, clicking through the same flow over and over.

After: One command. Five seconds. All six services in one view, grouped by priority, with direct booking links.

If I check availability three times a week, that's about seven hours saved per year. Not life-changing, but satisfying. And I never have to click through that terrible interface again.

how ai made this possible

Total time: about 30 minutes. Most of that was waiting for network requests and tweaking the UI.

The actual reverse engineering—finding endpoints, understanding auth, building the client—took maybe 10 minutes of prompting. The AI handled tool setup, parsed network traffic, identified patterns, generated working code. I just described what I wanted and iterated.

The hardest part was getting the booking URL format right. I gave the AI one working example, and it figured out the pattern.

This is what nano apps are about. Not building something for everyone—building something for you, fast. The tools exist. The APIs are there. You just need to connect them.

Most booking UIs are just wrappers around APIs anyway. The data is there, hidden behind clicks. OAuth tokens can be captured by simulating what the browser does. And AI makes the whole process trivial—it can parse network traffic, identify patterns, generate working code in minutes.

What started as frustration with a clunky interface became a 30-minute project. Now checking availability is a single command instead of 36 clicks.

That's the power of nano apps. Build your own tools. Solve your own problems. Don't wait for someone else to fix the interface.