TripMixer — A Shared Playlist for a Road Trip

01: The Brief

A group of friends is heading out on a road trip and everyone wants "their" music in the car. Usually one person makes the playlist and the rest put up with it. I needed a way to build a shared playlist with no sign-ups, in a couple of minutes, so everyone adds their own — and the result can be taken to any music service.

[ SYS_IMAGE_LOAD ] Creating a playlist: title, name, per-person quota

02: How It Works

1. The owner creates a playlist — title, name, per-person quota — and gets a link.
2. Friends open the link, say who they are (no account, the name lives in the browser) and search for tracks. Every result has cover art and a 30-second preview: you can listen before adding.
3. The owner finishes the build. The service works out the order, optionally tops the list up with a few tracks "in the spirit", and hands over a file — M3U, CSV, TXT or a download script.

[ SYS_IMAGE_LOAD ] Catalogue search: cover, duration, preview, "Add" button

03: The Key Decision — Throwing Away Version One

The first version did something else: it merged participants' existing playlists by link and looked for overlap. Measurements on real data showed the idea didn't work:

• zero overlap between participants — prioritising shared tracks never fired once;
• tracks arrived as "Artist — Title" strings and had to be identified in a catalogue: 223 of 600 weren't recognised, tempo was found for 11%;
• 350 tracks took about two minutes to assemble.

"Flipping the scenario removed all three problems at once: when a person picks a track from the catalogue, the track already has exact metadata, cover art and a preview. Nothing to identify, nothing to wait for."

That's the project's main lesson — sometimes the right move isn't to optimise the algorithm but to change where the data enters.

04: Search Across Two Catalogues With No Keys

Search runs in parallel against Deezer and iTunes Search — both free, neither needs a key. Results are merged by the "artist + title" pair: duplicates collapse, the Deezer record gets its genre from iTunes. The result order is deliberately not re-sorted: an attempt to boost popular tracks put "The Weeknd — Starboy" first for the query "daft punk".

05: Sequencer — Order, Not Selection

Nothing gets discarded here — every track was added by a real person, and dropping someone's pick means offending them. The algorithm only decides the sequence:

• Even contribution. Participants alternate in proportion to their track count. The naive "whoever has the most left goes next" pushed a single track to the very end at a 4-to-1 contribution.
• Smooth tempo. The next track is the closest by BPM, so you don't jump from a ballad to a banger.
• Artist spacing. Two tracks by the same artist never sit side by side.

# Track the debt: how many of this participant's tracks should have played by now.
share = {who: len(items) / total for who, items in remaining.items()}
while any(remaining.values()):
    position = len(ordered)
    who = max(
        (k for k in remaining if remaining[k]),
        key=lambda k: (share[k] * (position + 1) - played[k], -first_seen[k]),
    )
    # Same artist back-to-back is the worst option — push it to the back of the queue.
    best = min(
        remaining[who],
        key=lambda t: (_artist(t) == last_artist, _tempo_distance(t, previous)),
    )

[ SYS_IMAGE_LOAD ] Playlist board: stats, per-person contribution, genres, track list

06: The AI Layer — Optional and Verifiable

With a key present, a model (Gemma via the Google API) joins in: it suggests tracks in the spirit of the list and arranges the order for continuous listening. Two principles:

• Hallucinations are filtered automatically — every suggestion is looked up in the catalogue; an invented track won't be there.
• The ordering reply is checked for being an honest permutation. Any loss or duplicate would mean someone's track vanished — such a reply is rejected outright and the sequencer takes over.

if sorted(indexes) != list(range(len(tracks))):
    warnings.append(
        "The model lost or duplicated tracks — the regular algorithm was used."
    )
    return None, warnings

return [tracks[i] for i in indexes], warnings

Without a key the service works in full.

[ SYS_IMAGE_LOAD ] Build step: tempo from previews, AI options, export to M3U / CSV / TXT / .sh

07: Infrastructure

• Redis with a key layout built for concurrent additions: tracks as a list via RPUSH, the quota via INCR, so friends' parallel requests don't overwrite each other. A link lives for a week.
• Vercel: static files on the CDN, a Python function only under /api. Had to work out that public doesn't make it into the function bundle — the SPA route /p/:id is solved with a platform-level rewrite.
• Tests for the sequencer, export, AI response parsing and storage.

08: Interface

A dark neutral background, thin borders, one accent gradient. A few decisions I'm not ashamed of:

• One player for the whole app instead of an <audio> per row — otherwise previews would play simultaneously.
• Search doesn't reset after adding — people usually grab several tracks by the same artist in a row.
• The quota is a four-value toggle, not a stepper: few options, nothing to aim at.
• Fonts are sliced by unicode-range: the Russian UI loads only the subset it needs, four files — about 140 KB. Unbounded for the heading, Golos Text for the UI, Geist Mono for numbers and durations.
• No WebGL backgrounds, on purpose — megabytes for a two-second effect.
• Animations respect prefers-reduced-motion: content never depends on whether an animation ran.

[ SYS_IMAGE_LOAD ] Create, search and export on a phone

[ SYS_IMAGE_LOAD ] Landing: "One playlist for the whole crew"

09: Stack

Python / FastAPI · Redis · React + Vite + Tailwind · Vercel (static + Python function)

10: Outcome

A working service you can use with no sign-up and not a single API key. Three things I took from the project: measure a hypothesis on real data before polishing it; design so that AI errors are caught structurally, not by eye; and don't be afraid to throw away version one when the numbers say it doesn't work.