Tailscale

We're hiring a Product Manager to own what it's like to build a Tailscale-native application - software with Tailscale connectivity and identity built in from the start.

You'd own the original front door to that world: TSNet, the Go library that puts a Tailscale node inside an application in a few lines of code; tailscale-rs, our new Rust-based SDK family (including C++, Python, and Elixir); the tailscale CLI powering scripting, automation, and CI; and the core Tailscale client library.

Products already get built this way, inside and outside Tailscale. Aperture, our AI connectivity gateway, and Tailscale PAM run on these primitives. So do LM Studio, NVIDIA, and Namespace.co, who embed Tailscale directly into their applications to give their users secure remote access, reach into customer networks safely, and bridge cloud environments without VPN gymnastics. One of those teams went from zero to a working embedded integration in hours. Your job is to make that the normal outcome for thousands of more applications.

Today this experience is engineering-led and the developer journey is uneven. The API is powerful, but the on-ramp from "I read a blog post" to "Tailscale is running inside my product" has real friction: auth key handling, onboarding flows designed for humans instead of embedded apps, docs and examples that don't yet tell a coherent story. You'll own that journey end to end and define, concretely, what it means to build a Tailscale-native application including the golden paths, the reference patterns, the APIs, and the developer experience that makes people say "wait, that's all it took?"

You'll report to Ross Kukulinski, VP Product, and work closely with the Rust, Golang, and Clients engineering teams, plus the internal product teams and external partners building Tailscale-Native Applications.

• Own the roadmap for the native apps experience: TSNet, tailscale-rs, and the tailscale CLI
• Define what "Tailscale-native application" means - the reference architectures, golden paths, and embedding patterns, packaged as docs, examples, and sample apps developers can build from
• Own the developer experience end to end: the on-ramp from blog post to running embedded node, API ergonomics, error messages, docs that work, examples that compile, and upgrade paths that don't burn early adopters
• Set the Rust SDK family strategy: which TSNet capabilities to port, which to skip, in what order, and how to position the library to developers.
• Treat the CLI as a product in its own right: scripting ergonomics, output conventions, automation surfaces, and the experience for platform and SRE teams running tailscale in CI and infrastructure-as-code
• Run the internal dogfood loop. Aperture and Tailscale PAM are built on these primitives; make those teams your most demanding customers and turn their friction into roadmap.
• Partner with GTM and Customer Success on embedding deals - AI platforms, developer tools, and infrastructure software shipping Tailscale inside their products - and let what you learn set priorities
• Engage developers where they live (GitHub issues, Discord, office hours) and build a coherent picture of what embedded developers need

• 6+ years in product management, or a software engineering background moving into product, with real time spent on a developer-facing product: an SDK, API, CLI, library, or developer tool
• You've shipped developer-facing features that developers used in production, and lived with the consequences of your design choices - naming, defaults, error behavior, versioning
• You can read Go and/or Rust and hold a credible technical conversation about API and SDK design 
• You have taste in developer experience: opinions about API ergonomics, docs, error messages, and getting-started flows, with examples to back them up
• You do customer research the way developer products require it - reading GitHub issues, lurking in Discord, running office hours, and finding the pattern in the noise
• You turn ambiguous scope into shipped increments, close the loop after launch, and keep teams informed along the way

• Hands-on Go or Rust experience - you've built something real, even as a side project
• Time at a developer platform company with a strong SDK motion (e.g. Stripe, Twilio, Auth0, Vercel, Supabase, HashiCorp)
• Open-source community experience: contributor experience, issue triage, balancing commercial priorities with community needs
• Enough networking, zero-trust, or VPN familiarity to understand what embedding Tailscale does for a developer
• Experience designing CLIs or scripting surfaces for platform and SRE teams
• Public technical writing, talks, OSS contributions, or developer-tooling side projects
• LLMs and coding agents as part of your daily product workflow

As a company, we strive to maintain fair and equitable compensation practices within our team across all roles and all levels. Tailscale's compensation package includes base salary, equity, and comprehensive benefits. The salary range displayed on each job posting represents the target range for a new hire's base salary. Individual offers may vary based on experience and skill set.