Felipe Saint-Jean
· Hardware

Skip Docker: Run Services on Your Mac Mini with Tailscale and tmuxp

Hosting side projects from a Mac mini without containers.

Your Mac mini is already running 24/7 as a media server, Time Machine backup, or general household appliance. Why not run your side projects on it too?

This guide covers a simple setup for small developers who want to run a frontend, backend, and expose them to the internet without Docker, Kubernetes, or a cloud provider charging you $20/month for a hobby project.

Disclaimer: This setup is not suitable for production enterprise services. If your startup gets acquired and the new CTO asks about your infrastructure, do not show them this article.

The Setup

You have:

  • A Mac mini (or any always-on machine)
  • A web frontend (React, Vue, whatever)
  • A backend API (Node, Python, Go)
  • A desire to access these from anywhere

Why Not Docker?

Docker is great. It’s also another layer of abstraction, another thing to debug, and another 4GB of RAM for Docker Desktop on macOS. For a personal project or small SaaS with twelve users, running processes directly is fine. Your code already runs on your machine. Just keep it running.

Tailscale Funnel: Expose Services Without Port Forwarding

Tailscale Funnel lets you expose local ports to the public internet through Tailscale’s infrastructure. No port forwarding, no dynamic DNS, no nginx reverse proxy configuration.

Install Tailscale

brew install tailscale

Start the service and authenticate:

sudo tailscaled &
tailscale up

Enable Funnel

First, enable HTTPS and Funnel in your Tailscale admin console under DNS settings. Then expose your service:

# Expose your backend on port 8000
tailscale funnel 8000
# Or expose on a specific path
tailscale funnel --set-path=/api 8000

Your service is now available at https://your-machine-name.tailnet-name.ts.net.

For multiple services, use tailscale serve for internal Tailnet access or run multiple Funnel instances on different paths.

tmuxp: One Command to Start Everything

tmuxp is a tmux session manager that uses YAML config files. Instead of opening three terminal tabs and typing commands, you run tmuxp load project and everything starts.

Install tmuxp

brew install tmux
pip install tmuxp

Create Your Launch File

Create ~/.tmuxp/myproject.yaml:

session_name: myproject
windows:
- window_name: services
layout: tiled
panes:
- shell_command:
- cd ~/projects/myproject/frontend
- npm run dev
focus: true
- shell_command:
- cd ~/projects/myproject/backend
- source venv/bin/activate
- python main.py
- shell_command:
- tailscale funnel 3000

Launch Everything

tmuxp load myproject

This opens a tmux session with three panes: your frontend dev server, your backend, and the Tailscale tunnel. All running, all visible.

Attach and Detach

  • Detach from session: Ctrl-b d
  • Reattach later: tmux attach -t myproject
  • Kill session: tmux kill-session -t myproject

Your services keep running after you detach. Close your laptop, go to bed, check them from your phone tomorrow.

A More Complete Example

Here’s a real-world config with a Next.js frontend, FastAPI backend, and Tailscale exposing both:

session_name: saas-app
start_directory: ~/projects/my-saas
windows:
- window_name: frontend
panes:
- shell_command:
- cd frontend
- npm run dev -- --port 3000

- window_name: backend
panes:
- shell_command:
- cd backend
- source .venv/bin/activate
- uvicorn main:app --reload --port 8000

- window_name: tunnel
panes:
- shell_command:
- tailscale funnel --bg 3000
- tailscale funnel --bg --set-path=/api 8000
- echo "Services exposed. Check https://your-machine.ts.net"
- tail -f /dev/null

- window_name: logs
panes:
- shell_command:
- tail -f backend/logs/app.log

Auto-Start on Boot (Optional)

If you want services to start when your Mac boots, create a launchd plist or simply add tmuxp to your login items. For a Mac mini running headless:

# Add to ~/.zshrc or create a login script
tmuxp load myproject -d # -d starts detached

When to Actually Use Docker

Use Docker when you need reproducible environments across machines, when onboarding other developers, or when deploying to cloud infrastructure that expects containers. For your personal Mac mini running your side project? Probably unnecessary.

Summary

  1. Install Tailscale, enable Funnel
  2. Write a tmuxp YAML file with your services
  3. Run tmuxp load project
  4. Access your services from anywhere via https://your-machine.ts.net

Total infrastructure cost: $0. Total complexity: three processes in tmux. Good enough for your twelve users, your demo day, or your personal tools.

Just don’t put this in your SOC 2 documentation.

Originally published on Medium

Contact

Tell me what you're building.