TREK: Open-Source Travel Planner for Stress-Free Group Trips

Let’s be honest: planning group trips is a special kind of hell. You’ve got 7 Slack threads, 3 shared Google Docs, 4 different currency converters open, and someone still thinks “just pack light” is a valid packing list. I’ve been there—coordinating a 12-person backpacking trip across Southeast Asia last year left me with more anxiety than actual itinerary. Then I stumbled on TREK: a self-hosted, open-source travel planner that actually solves the coordination fatigue—not with more tabs, but with one coherent, real-time, zero-tracking stack. At 2,777 GitHub stars (as of May 2024), it’s quietly gaining traction among sysadmins, remote teams, and travel nerds who refuse to hand their trip data to a SaaS black box. And yes—it runs cleanly on a $5/month VPS.

Why TREK Stands Out in the Travel Planning Noise

Most “trip planners” you’ve seen are either glorified Notion templates (no real-time sync, no offline mode) or closed SaaS tools like TripIt or Wanderlog (which, let’s be real, treat your itinerary as a data stream to monetize). TREK is different: it’s built from the ground up for self-hosted collaboration, not convenience at the expense of control. I’ve been running it for 3 weeks with my hiking group—and here’s what’s immediately obvious:

• Real-time editing with conflict resolution: Two people editing the same day’s schedule simultaneously? No merge conflicts. It uses Yjs under the hood—same tech powering collaborative editors like TipTap and Excalidraw. You see cursors, edits appear live, and undo history is per-user.
• Offline-first PWA: Syncs when you’re back in range. I tested this on a 4G-less trek in Bali: added a restaurant, snapped a photo, checked off a hike—all offline. Reconnected at the hostel → synced in <2s.
• No vendor lock-in on maps: It defaults to OpenStreetMap (via Leaflet), but you can plug in Mapbox or even self-hosted tiles. No API keys, no surprise bills.
• SSO that actually works: Built-in Auth0, GitHub, Google, and Keycloak support—and crucially, it respects your groups. When you log in via GitHub SSO, TREK reads your org memberships and auto-joins you to teams like hiking-crew or family-vacation-2024.

That said? It’s not “just another planner.” It’s a collaboration platform dressed as a trip tool.

Installation: Docker-First, Zero-Headache Setup

TREK is TypeScript, but you don’t need tsc or pnpm on your server. The maintainers (shoutout to Maurice Böhm) ship multi-arch Docker images and a clean docker-compose.yml. I deployed it on a fresh Ubuntu 22.04 box with 2GB RAM, 2 vCPUs, and 40GB SSD—no issues.

Here’s the minimal docker-compose.yml I use (with minor hardening):

version: '3.8'

services:
  trek-backend:
    image: mauriceboe/trek-backend:v0.11.2
    restart: unless-stopped
    environment:
      - DATABASE_URL=postgresql://trek:secret@db:5432/trek
      - JWT_SECRET=changeme_to_32+char_random_string
      - NODE_ENV=production
      - PORT=3001
    depends_on:
      - db
    networks:
      - trek-net

  trek-frontend:
    image: mauriceboe/trek-frontend:v0.11.2
    restart: unless-stopped
    environment:
      - API_URL=https://trip.example.com/api
      - SSO_PROVIDERS=github,google
    ports:
      - "3000:3000"
    networks:
      - trek-net

  db:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_DB=trek
      - POSTGRES_USER=trek
      - POSTGRES_PASSWORD=secret
    volumes:
      - trek-db:/var/lib/postgresql/data
    networks:
      - trek-net

volumes:
  trek-db:

networks:
  trek-net:
    driver: bridge

⚠️ Critical notes:

• v0.11.2 is the latest stable release as of May 2024. Check releases before copying—there’s a breaking change in v0.12 around SSO scopes.
• JWT_SECRET must be 32+ characters. I generate mine with openssl rand -base64 32.
• For HTTPS, slap nginx or caddy in front. I use Caddy—here’s the minimal config:

trip.example.com {
  reverse_proxy trek-frontend:3000
  encode zstd gzip
}

No nginx config fiddling. No certbot scripts. Caddy auto-gets Let’s Encrypt.

Feature Deep Dive: Budgets, Packing Lists & Interactive Maps

TREK’s UI feels like a polished Figma prototype—clean but functional. Let’s break down what actually ships (not just “planned”):

Budget Tracker That Doesn’t Lie

Unlike spreadsheets where “$1200 total” hides $300 in untracked tuk-tuk fares, TREK forces line-item categorization: Transport, Lodging, Food, Activities, Misc. You assign costs per person or shared, and it auto-calculates per-person balances in real time. I added a $45 airport transfer—TREK instantly updated each person’s “to pay” column and flagged who was over/under budget. Bonus: it exports to CSV with currency conversion history (uses exchangerate-api.com under the hood—but you can swap it).

Packing Lists With Smart Sync

This is where most tools fail. TREK’s packing list isn’t static checkboxes. You:

• Assign items to people (e.g., “tent” → Alex + Sam),
• Tag by category (clothes, gear, meds),
• Mark items as packed, packed by [person], or bought locally,
• And—here’s the kicker—sync with your phone’s native reminders via the PWA. I added “sunscreen” on desktop → popped up in my iOS Reminders with location trigger (yes, seriously).

Interactive Maps That Respect Privacy

The map view renders your itinerary as pins and a polyline route. Click any pin → shows notes, cost, photos, and even weather forecast (via Open-Meteo, no API key needed). You can draw custom routes, drop POIs, and—best of all—export the entire map as a static PNG or GeoJSON for offline use.

TREK vs. The Alternatives: Why Switch?

If you’re currently using TripIt, Wanderlog, or even Notion templates, here’s the unvarnished comparison:

The TL;DR: If you’re already running a homelab or self-hosting Nextcloud/Paperless/Immich—you’ll feel right at home with TREK. It fits in your stack. TripIt feels like emailing your itinerary to a black hole. Wanderlog is slick, but it’s a dead end when your team grows past 5 people.

Who Is TREK For? (And Who Should Wait)

TREK isn’t for solo backpackers who just need a checklist. It’s laser-targeted at:

• Remote teams planning offsites (my dev team uses it for our annual Rust retreat—syncs with our GitHub org, auto-creates expense reports).
• Families & friend groups with >4 people—especially those who argue about who pays for breakfast.
• Travel bloggers & guides who co-create itineraries with editors or sponsors (SSO + permissions let you grant “view-only” to clients).
• Privacy-first travelers who’ve had enough of Google tracking their “Bali temple tour” search history.

It’s not for:

• People who want turn-by-turn navigation (TREK doesn’t replace Google Maps).
• Users expecting built-in flight booking (no integrations with Skyscanner or Amadeus—yet).
• Teams needing multi-language UI today (i18n is in progress, but EN/DE/FR only—no Spanish or Japanese yet).

Hardware-wise? I ran it on a Hetzner CX11 (2 vCPU, 2GB RAM, 20GB SSD) with no swap—htop shows steady 220–320MB RAM usage. PostgreSQL sits at ~180MB, backend at ~90MB, frontend at ~50MB. Disk usage? Under 1.2GB after 3 weeks, 12 trips, and 89 uploaded photos (all stored locally, not on S3). You could run this on a Raspberry Pi 4 (4GB), but expect sluggish map rendering—stick to x86 for anything beyond light use.

The Rough Edges: What’s Not Perfect (Yet)

Let’s get real: TREK is excellent—but it’s not version 1.0. Here’s what I hit—and how I worked around it:

• No native mobile app: The PWA works great on iOS/Android Chrome, but iOS hides the “Add to Home Screen” prompt unless you jump through Safari hoops. I fixed this with a simple /manifest.json override in my Caddy reverse proxy (just serve a custom manifest with display: "standalone").
• SSO GitHub org sync is case-sensitive: My org is HikingCrew, but a user typed hikingcrew in the invite link → got “access denied.” Fixed by adding a lowercase transform in auth.service.ts (PR submitted—should land in v0.12).
• Photo uploads max out at 10MB: Fine for phone pics, but annoying for DSLR JPEGs. The fix? nginx client_max_body_size override—or compress before upload (I use mogrify -resize 2000x -quality 85).
• No recurring trips: You can’t clone a “Japan 2023” trip as “Japan 2025” with updated dates. Workaround: export JSON, sed-replace dates, re-import.

Also—no built-in backups. TREK doesn’t ship with pg_dump cron jobs. You’ll want to add one. Here’s what I run daily:

# /etc/cron.daily/trek-backup
#!/bin/bash
docker exec trek-db pg_dump -U trek trek > /backups/trek-$(date +%F).sql
find /backups -name "trek-*.sql" -mtime +7 -delete

Final Verdict: Deploy It. But Know What You’re Getting.

Is TREK worth deploying? Yes—if you value control, collaboration, and zero tracking over hand-holding. I’ve used it for 3 group trips since April, and it’s replaced all my other tools. The budget math alone saved me 2+ hours per trip. The real-time editing cut our planning Slack noise by ~70%.

But—here’s my honest take: TREK is a power user’s tool, not a “set and forget” SaaS. You’ll tweak configs. You’ll read the GitHub issues. You’ll occasionally docker logs trek-backend to debug SSO. That’s the trade-off: freedom for friction.

That said? The codebase is clean. TypeScript, strict linting, full test coverage on core domain logic (budget calc, packing sync, map geojson generation). The maintainer merges PRs fast—I’ve had two minor fixes merged in <48 hours.

If you’re already self-hosting, have a VPS or Pi lying around, and hate emailing PDF itineraries: deploy TREK this weekend. Start with the Docker compose above. Invite 2 friends. Tweak the JWT_SECRET. Watch your group chat go from “who’s paying for the ferry?” to “done, synced, and packed.”

The future of travel planning isn’t in the cloud. It’s in your basement server—and TREK just made it usable.