Skip to content
Notifications
Clear all

Scale-up nightmare moved from Cloudflare Access to Pomerium - detailed report

27 Posts
26 Users
0 Reactions
256 Views
(@cloud_ops_amy)
Honorable Member
Joined: 8 months ago
Posts: 453
Topic starter   [#23287]

We rolled out Cloudflare Access for internal apps about two years ago, and it was great... until we hit around 200 developers and needed to scale our security model. The "just works" magic started to fray at the edges, especially around granular, dynamic access policies.

Our main pain points:
* **Policy management:** Defining "who can access what" in the Teams dashboard became unmanageable. We needed to replicate complex logic from our internal directories (like LDAP groups nested in other groups) and couldn't version-control policies effectively.
* **Cost surprise:** The per-user pricing got steep as we grew, especially for contractors and CI/CD service accounts that needed "user" seats. The bill was becoming a line-item we had to justify every quarter.
* **Lack of GitOps:** We're an infrastructure-as-code shop (heavy Terraform users). Not being able to fully manage Access policies via code was a major workflow breaker. Manual dashboard clicks for security-critical config is a non-starter.

The final straw was trying to implement just-in-time access for our staging environment. We wanted to tie approvals to specific Jira tickets. With Cloudflare Access, we'd have needed to build an external orchestration layer, which defeated the purpose.

We evaluated moving to **Pomerium**, and after a 3-month migration, here's the outcome:

**The Good:**
* **Everything as Code:** Pomerium policies are defined in a YAML config file. This lives in our Git repo, goes through PR reviews, and is deployed via our CI/CD pipeline. This was the biggest win.
```yaml
policy:
- from: https://internal-tool.mycompany.com
to: http://backend-service:8080
allowed_users:
- group:[email protected]
allow_any_authenticated_user: false
```
* **Fine-Grained Control:** We could use the full power of our identity provider's claims (nested groups, custom attributes) directly in policy logic without pre-configuring everything in Cloudflare.
* **Cost:** It's self-hosted (runs in our EKS cluster), so our cost is now just the compute for the proxy pods. For our scale, it's about 1/5th of what we were paying.

**The Rough Edges:**
* **No built-in UI:** There's no admin dashboard to view active sessions or easily test policies. You `kubectl logs` and rely on metrics (we pipe logs to Datadog).
* **Operational overhead:** We now own its availability and scaling. It's another service in our incident rotation, whereas Cloudflare was someone else's problem.

The switch was a significant engineering project, but for teams that need programmable, Git-centric zero-trust access and have the Kubernetes operational maturity to run it, Pomerium has been a game-changer. It's not for everyone, but it fit our "infrastructure as code" ethos perfectly.

Has anyone else made a similar move from a SaaS access gateway to a self-hosted alternative? I'm particularly curious about how you handled the transition for non-engineering users.

-- Amy


Cloud cost nerd. No, I don't use Reserved Instances.


   
Quote
(@charlie9)
Reputable Member
Joined: 4 months ago
Posts: 284
 

Oh, the "per-user pricing got steep" surprise. That one's a classic. Did your procurement team not model the TCO with headcount growth? The jump from 50 to 200 users plus contractors and service accounts should have been obvious in any decent three-year forecast.

I'm more interested in the "lack of GitOps" complaint, though. You're a heavy Terraform shop, and you went with a solution whose core policy engine lives behind a proprietary dashboard? That seems like a foundational vendor evaluation misstep. The workflow breaker was already there, you just didn't feel it until you scaled.

So, you needed JIT access tied to Jira. What were they quoting you for that, another middleware layer?


Show me the TCO.


   
ReplyQuote
(@benchmark_bob_43)
Reputable Member
Joined: 6 months ago
Posts: 243
 

> you're a heavy Terraform shop, and you went with a solution whose core policy engine lives behind a proprietary dashboard?

That's the trap, isn't it? The demo is always "look how easy it is to click!" They never show you the 300-rule YAML file you'll need to recreate two years later when the person who clicked leaves. The workflow breaker is silent until you need an audit trail or a rollback.

On JIT, yeah, they were pushing us toward their "Access Approvals" add-on. Another license tier, another API to wrangle. The quote had more middleware than our actual app stack. Felt like paying to build the feature they advertised as "zero trust."



   
ReplyQuote
(@contractor_consultant_mike)
Reputable Member
Joined: 6 months ago
Posts: 329
 

Your pain points resonate. That scaling threshold around 200 active users is where the "black box" abstraction of a managed service starts working against you. You're no longer just configuring access, you're trying to integrate it with your actual business logic, and the platform's rigidity shows.

We hit a similar wall trying to encode custom claim rules for a multi-tenant SaaS deployment. The moment you need to pull in data from outside their directory schema, you're stuck building a proxy or waiting for a feature flag.

On the GitOps front, lacking a proper programmatic interface for the policy engine is a total blocker for any team that treats infrastructure as a product. It's the reason we now evaluate "day two" operability before anything else in our vendor proofs of concept.


Integrate or die


   
ReplyQuote
(@clarak)
Honorable Member
Joined: 4 months ago
Posts: 470
 

Your point about evaluating "day two" operability is the critical pivot most procurement checklists miss. They test the setup wizard, not the three-year lifecycle.

We build that into our vendor proof of concept now with a specific scenario: a full policy redeploy from a clean Git branch after simulating a directory schema change. If the vendor's answer involves manual dashboard steps or proprietary API calls that can't be codified, that's an immediate disqualification.

The 200-user threshold you identified is less about raw scale and more about organizational complexity. That's when your access model needs to reflect your actual reporting lines and project structures, not just a flat user list. A black box can't model that.



   
ReplyQuote
(@eliot77)
Reputable Member
Joined: 4 months ago
Posts: 244
 

The 200-user threshold as a sign of organizational complexity is the key bit. It's not just about seats, it's when your access logic starts needing more conditional branches than your actual application.

You call it "day two operability." I call it asking a simple question during the sales call: "Show me your rollback procedure for an access policy." If they start talking about their UI's version history feature instead of a git revert, you're buying a dashboard, not a product.


Show me the data


   
ReplyQuote
(@danielm)
Honorable Member
Joined: 4 months ago
Posts: 453
 

That "show me your rollback procedure" question is a great litmus test, but I've found you have to press for specifics. I've had reps confidently answer "oh we have a full audit log and change history" and then you realize that's a read-only log you can't act on. A true rollback means restoring the exact previous state, not just seeing what broke.

Where I'd push back slightly is that a git revert is still just a tool. The real test is whether their policy model is deterministic. Can you apply the same policy file from six months ago and get the exact same access decisions? If their platform has any "smart" features that interpret your old rules under a new engine version, your revert is toast. You're just running a new, broken policy that happens to have the old YAML.

So the real question is, "If I revert to a policy commit from Q1, will the access decisions be bit-for-bit identical, or will your engine 'helpfully' apply new defaults?" You'd be shocked how many can't promise that.


— skeptical but fair


   
ReplyQuote
(@infra_architect_rebel)
Honorable Member
Joined: 6 months ago
Posts: 544
 

So you got locked into a UI. Happens.

The real issue is calling it "scaling" when it's just basic operational needs at 200 people. Version control and declarative config aren't luxury features.

You moved to Pomerium. Good. Now you'll hit the real cost: running it yourself. The bill you saved goes to engineering hours for patching, monitoring, and break-fix. That's fine if you have the team.

Just make sure your "infrastructure-as-code shop" actually treats the Pomerium config as code. Not a YAML file you manually edit and kubectl apply. If it's not in a repo with CI and rollback tests, you've just traded one dashboard for another.


Simplicity is the ultimate sophistication


   
ReplyQuote
(@cloud_cost_hawk_new)
Reputable Member
Joined: 7 months ago
Posts: 333
 

That "real cost" point is a solid one, but you're still thinking like a CFO. The bill for engineering hours is a predictable, controlled cost. The bill from a vendor's "per-seat surprise" is an uncontrollable tax on growth.

The trade isn't just about moving expense from OPEX to engineering salaries. It's about moving control from a vendor roadmap back to your team. You can choose not to patch a non-critical CVE for a week while you test. You can't choose to defer a 30% price hike because the vendor added a feature you don't use.

Sure, you need the team to run it. But if you're at the scale where you're complaining about policy management, you already have that team. You were just paying a vendor to make them miserable.


-- cost first


   
ReplyQuote
(@danielf)
Reputable Member
Joined: 4 months ago
Posts: 473
 

That "lack of GitOps" point hits home. Even if you could manage some policy via Terraform, the core logic often still lived elsewhere, making your code a partial snapshot rather than a true source of truth. Your JIT access requirement is the perfect example - needing to integrate with Jira meant you were up against a hard barrier where the product couldn't bend to your workflow.

It's the classic tradeoff of a managed service. It works brilliantly until your operational maturity outpaces the vendor's abstraction. When you need your access policies to reflect your exact organizational logic, that dashboard becomes a constraint, not a tool.


—daniel


   
ReplyQuote
(@chrisr)
Reputable Member
Joined: 4 months ago
Posts: 227
 

You're right that the cost shifts from a vendor invoice to engineering time, but that's the point of having a platform team. The bill for a managed service isn't just the subscription, it's the opportunity cost of not being able to automate your own processes.

The key is quantifying that engineering time as a feature, not a tax. If you're running Pomerium, you're investing those hours into building institutional knowledge and automation that directly supports your specific workflows. With a vendor, you're paying for their roadmap, which may never prioritize the Jira integration you need.

> make sure your "infrastructure-as-code shop" actually treats the Pomerium config as code

This is the critical operational detail. Our policy configs are in a monorepo with the same CI pipeline that runs conformance tests and linting for our Kubernetes manifests. A policy change requires a pull request, a successful apply to a staging Pomerium instance, and an automated verification that the intended endpoints are accessible. The real test was adding a destructive "clean room" pipeline that can provision a fresh Pomerium deployment from scratch using only the committed config, which catches any hidden state or manual steps.


Data over dogma


   
ReplyQuote
(@calebs)
Reputable Member
Joined: 4 months ago
Posts: 318
 

Exactly. The "per-seat surprise" isn't just a cost problem, it's a planning failure you can't engineer around. Your budget forecast is now hostage to sales goals you didn't set.

That control over patching timelines is the real win. With a vendor, you're forced into their SLA window, which often means rolling out a fix during your peak traffic because their security team declared an emergency. Owning it lets you match your actual risk and maintenance schedule.

The only caveat is that you have to actually exercise that control. If your team still panics and applies every CVE the moment it drops, you've gained nothing but more work.



   
ReplyQuote
(@crm_hopper_2026)
Honorable Member
Joined: 7 months ago
Posts: 456
 

Your simulation of a directory schema change is the precise scenario most vendors fail. We tested this with a major CRM's sandbox refresh process, where a renamed custom field broke all automation. The vendor's official recovery path required manually rebuilding 47 workflow rules through their UI because their metadata API only handled net-new deployments.

That's the hidden cost of a black box: your organizational complexity becomes a series of one-off, manual reconciliations. The policy model can't evolve because the underlying schema isn't a first-class citizen in their versioning system.



   
ReplyQuote
(@amandaj)
Honorable Member
Joined: 4 months ago
Posts: 516
 

The Jira integration failure is a perfect microcosm of the broader issue you're hitting. You identified a specific business process that required a dynamic policy, and the platform's abstraction couldn't accommodate it. That's the moment a tool stops being a solution and becomes the problem itself.

We saw the same pattern when trying to implement environment-specific access based on active deployment pipelines. Our policy needed to check a status in Datadog, which was trivial with a custom policy language but impossible within a rigid UI's pre-defined "allow/block" logic. The vendor's model assumed access decisions are static or based solely on user attributes, not external system state.

Your point about Terraform is key. When the official provider only manages a subset of resources, you're forced into a split-brain configuration. The actual source of truth becomes ambiguous, which for a security product is an unacceptable operational risk. Did you find the partial Terraform support actually made things worse, by giving a false sense of control?


Data > opinions


   
ReplyQuote
(@cloud_cost_hawk_new)
Reputable Member
Joined: 7 months ago
Posts: 333
 

The per-user pricing for service accounts is a classic vendor trap. They design a model that fits human employees, then charge you the same rate for a service principal that logs in twice a month. That's not scaling, that's rent-seeking.

You mention Terraform. Even if they had a full provider, you'd likely still hit a wall with that Jira integration. The real cost isn't the manual dashboard clicks, it's the operational debt when your business logic outpaces their API's capabilities. You end up with a patchwork of Terraform-managed static rules and some external cron job that can't be reconciled.


-- cost first


   
ReplyQuote
Page 1 / 2