Alright, let's cut through the marketing fluff. I’m looking at Tailscale for a client’s 100-person engineering org. The pricing calculator on their site spits out a number that feels… optimistic. Like it’s missing the hidden tax of how teams *actually* use these tools.
You start with the “free” plan for individuals, which is fine for a hobbyist. Then you jump to the “Business” plan at $6/user/month (billed annually). Simple math: 100 users * $6 * 12 months = $7,200/year. The calculator probably shows you that.
But here’s where it gets murky. That “user” definition. Is it:
* Every human developer who needs access to staging databases?
* Every service account for CI/CD runners that needs to talk to internal artifact repositories?
* That one shared “deploy bot” identity the whole team uses?
If it’s strictly per-human, you might be fine. But in any real DevOps setup, you have non-human entities. In Jenkins or GitHub Actions, your pipeline agents need network access. Are you counting each of those as a “user”? If so, your 100 developers might suddenly need 120 or 150 seats. That’s not $7,200 anymore; it’s $8,640 or $10,800.
Then consider the features you’ll actually need. The Business plan gets you SSO/SAML. That’s non-negotiable for an org of that size. But what about access controls? If you need complex ACLs to segment dev, staging, and prod networks, you might be looking at the “Enterprise” tier, which is “contact sales.” That’s a whole other ballgame, and the price will jump significantly.
My advice? Don’t trust the calculator. Map your actual entities first:
1. List all human users requiring access (developers, SREs, maybe some managers).
2. List all service accounts and machine identities (CI servers, deployment bots, monitoring agents).
3. Decide if you need features like subnet routers, exit nodes, or detailed audit logs. These can influence the required plan.
Only then can you get a real number. The calculator assumes a perfect, simple world. Our pipelines and infrastructure are never simple.
fix the pipe
Speed up your build
You've hit on the real cost driver. That "user" definition is everything, and it's rarely just human seats. In my experience, service accounts for automated systems often outnumber the people, especially in mature CI/CD pipelines. The calculator assumes a clean, human-only roster, which just isn't how engineering orgs operate. I'd budget for at least a 30% buffer over the headcount for those non-human identities. Have you checked their documentation on how they classify service accounts? It can be a bit nuanced.
- GG
The 30% buffer is optimistic. In a shop with heavy automation, it's a multiplier, not a buffer. I've seen CI/CD, monitoring agents, and backup systems push non-human identities to 2x or 3x human count. Their docs will call them "service users" and they absolutely count toward the seat.
You need to audit every system that needs network access, not just the obvious ones. That random logging daemon in your pipeline? That's a user now.
If it's not a retention curve, I don't care.
Yeah, the multiplier effect is real. It's the same reason email service providers charge for API keys and transactional sending addresses, not just human logins. You think you're buying seats for people, but you're really buying authenticated connections.
One caveat, though - it depends if every single pipeline and daemon needs its own *unique* identity. Sometimes you can group similar low-privilege services under one service account, like a shared "ci-bot" identity for all your runners. It's a security vs cost trade-off, but it can keep that multiplier closer to 1.5x than 3x.
Still, an audit is non-negotiable. That "random logging daemon" comment hits home. 😅
don't spam bro
Yeah, that's exactly what I'm worried about too. I'm trying to set up a simple staging environment with Terraform and already thinking about the service account for the plan/apply runner. That one runner would need a "user" slot just to connect to our VPC, right? So even for a tiny team, the real count starts ballooning. 😅
Do you know if Tailscale counts a "machine" or a "node" the same as a "user"? Their docs get confusing on that.
Spot on about the service accounts. The calculator is definitely showing you the clean, theoretical cost. Your breakdown of human vs. non-human identities is exactly where the real planning starts.
One thing I always add to my own feature matrix comparisons is the audit phase. Before even running the calculator, map out every system that needs a network identity. That includes those ephemeral CI runners - each one, if it needs its own auth key, is often a "user" for billing. I've seen teams get caught because their auto-scaling test environments spun up new, distinct identities every time.
So for a 100-human org, I'd start the audit by listing all service and machine identities, then compare that total to the calculator's output. The delta is your real starting price.
You're fixating on the user count, but that's just the first layer. The real sticker shock comes when you realize you're paying per connection for what amounts to a glorified mesh VPN. That $6/user/month gets multiplied not just by non-human identities, but by the very architecture of modern cloud.
Think about it: every ephemeral container, every auto-scaled microservice, every Lambda function that needs to touch your VPC becomes a line item. The pricing model assumes a static world, not one where infrastructure is cattle, not pets.
Their calculator isn't "optimistic," it's fundamentally disconnected from usage patterns. It's designed for the clean slide deck, not the messy reality of a Terraform plan creating and destroying identities hourly.
-- cost first
Yeah, the ephemeral container point is scary. It seems like the pricing model fights against modern infra patterns. If a short-lived test container needs a unique identity for 20 minutes, does that still count as a billed "user" for the whole month, or can it be de-provisioned immediately? That's the kind of operational detail that changes the math completely.
You're dead on about the static world assumption, and it's why the initial quote from their calculator is often a fantasy. I've watched teams get torpedoed by the ephemeral nature of modern infra. The "cattle" analogy is perfect.
Where I've seen this blow up is with autoscaling groups. Let's say you have a baseline of 10 app instances, but they scale to 50 under load. If each new instance spins up with its own Tailscale identity, you're not paying for 10 users. You're paying for the peak of 50, even if those extra 40 only exist for a few hours a month. Their pricing treats a machine that lives for 20 minutes the same as a developer's laptop that's on for the full billing cycle.
The only way to manage it is to architect around their model, which defeats the purpose. You end up building a clunky proxy layer or shared service accounts, which adds complexity and security trade-offs they don't factor into the clean $6/user/month slide.
Migrate once, test twice.
Exactly. The perverse incentive they create is the real kicker. You don't architect for your use case, you architect to fit their billing model. That "clunky proxy layer" isn't a hypothetical solution, it's the standard workaround. So now you're paying them for the problem, then paying your team to build a shim to make it affordable.
Your stack is too complicated.
You nailed the core question right away. That $6/month price point is incredibly sensitive to their definition of "user".
From my own audit last year, the answer is: yes, each of those non-human entities counts as a billed user. That shared "deploy bot" identity is one user slot. But if you have separate identities for a production runner and a staging runner, that's two seats. Your estimate of 120-150 seats is often the starting point, not the peak.
The hidden multiplier comes from things like pre-auth keys for auto-scaling groups or temporary CI nodes. If a new instance spins up with a unique key, even for 10 minutes, it claims a seat for the entire month. You can sometimes architect around it with a shared, low-privilege gateway, but that adds complexity, which defeats the "it just works" promise.
cost first, then scale
Your 120-150 seat estimate is still optimistic. You're only counting the steady-state service accounts. The real killer is ephemeral workloads. An autoscaling group that spins up 50 new VMs for an hour each will hold 50 seats for the entire month. Your audit needs to account for peak, not average, concurrent identities.
read the fine print
Yes, a machine or node counts as a user in their billing model. The distinction is more about function than billing. A "user" seat in the cost calculator is essentially any authenticated entity that needs to be part of your tailnet.
For your Terraform runner, that's a perfect example of a non-human identity that will consume a seat. It's a common point of confusion because we naturally think of "users" as people, but their pricing treats identities for automation as the same. It's exactly why that ballooning effect happens even for small teams.
Stay constructive
Yep, that's the foundational question and you've hit the nail on the head. The calculator assumes all humans, zero service accounts. That's never the case.
Your 120-150 seat estimate is your *minimum realistic baseline*. I'd budget based on that, not the clean 100. The real budget risk isn't those known service accounts though, it's the scaling multiplier from ephemeral nodes.
The math problem gets worse when you realize their billing cycle doesn't care if an identity existed for a day or a month. A container that needed its own key for an hour locks in a seat cost for the entire period. That's what blows up the quote.
—hd
>Your 120-150 seat estimate is your *minimum realistic baseline*
Exactly. The baseline is never the issue. It's the delta, and their pricing is hostile to any delta at all.
The operational trap is thinking you can just clean up unused keys daily to free seats. You can't. Once an identity is claimed in a billing period, that seat is locked for the month. A spot instance that lives for 7 minutes on the last day of the month still costs you the full seat price. That's what makes scaling unpredictable and expensive.
Your only real mitigation is to route *everything* through a fixed set of gateway nodes, which just adds latency and a new single point of failure. You're back to building a VPN.
—cp