The DIY Approach
Go’s go-import meta tag mechanism is straightforward. You put this on a web page:
<meta name="go-import" content="go.yourcompany.com/user-svc git https://github.com/org/user-svc">
And go get knows where to fetch code. Sounds simple enough — so why not just hand-write a few HTML files and serve them with Nginx?
That’s exactly what many teams start with. Here’s what happens next.
Where It Breaks Down
Pain 1: One module = one HTML page + one Nginx rule
Each vanity import path needs its own HTML page with the correct meta tag, plus a location block in Nginx that serves it with ?go-get=1 detection. 5 modules is manageable. 50 modules means 50 HTML files and 50 Nginx rules.
Pain 2: HTTPS certificate management
Your vanity domain needs HTTPS. That means obtaining and auto-renewing a TLS certificate (Let’s Encrypt or similar), configuring them in Nginx, and monitoring expiry. One expired cert breaks go get for every module.
Pain 3: No management interface
Adding or removing a route means SSH-ing into the server, editing HTML files, editing Nginx config, running nginx -t, and reloading. There’s no CLI, no API, no audit trail.
Pain 4: go-source meta tags are tedious
The go-source meta tag enables source browser links (pkg.go.dev “Source” button). Each tag needs the correct URL pattern for GitHub, GitLab, or Bitbucket. Hand-writing these for 50 modules is error-prone.
Side-by-Side Comparison
| Dimension | Hand-Written Meta Tags | gvu |
|---|---|---|
| Setup time | Hours (Nginx + HTML + TLS) | Minutes |
| Per-module cost | New HTML + Nginx rule + reload | gvu add one command |
| HTTPS | Manual cert management | Automatic (on-demand TLS) |
| Wildcard routing | Rewrite rules or templates | One * pattern |
| go-source tags | Manual per-module | Auto-generated for GitHub/GitLab/Bitbucket |
| Major version support | Manual /v2, /v3 handling | Automatic |
| Route management | SSH + text editor | CLI (gvu list, gvu remove) |
| Operational overhead | Server + Nginx + cert renewal | Zero (hosted) |
| Availability | Depends on your infra | Managed SLA |
| Cost | Server hosting + your time | Free tier available |
When DIY Makes Sense
Hand-writing meta tags is a valid choice if:
- You have 1–3 modules and don’t expect growth
- Your team already runs Nginx with auto-renewing certs
- You enjoy infrastructure work and want full control
- You’re behind a corporate firewall with no external access
For everyone else, the DIY tax compounds quickly.
What gvu Adds
One command, zero infrastructure
gvu add go.yourcompany.com/auth https://github.com/org/auth-service
HTTPS certificate provisioned automatically. go-source meta tag generated. Major version (/v2, /v3) handled. Wildcard patterns supported. No server to babysit.
Wildcard routing: one rule for an entire org
gvu add 'go.yourcompany.com/dept/*' 'https://github.com/org/*.git'
New repos are automatically importable — no HTML files, no Nginx reloads.
Get Started
curl -fsSL gomodvanityurls.com/install.sh | bash
gvu add gomod.io/yourname/your-module https://github.com/your-org/your-module.git
Free forever for up to 5 routes. No signup required.