I run security for a distributed, fully remote organization spread across time zones. That context matters here: "fully remote" for us doesn't just mean people working from home, it means a large workforce scattered everywhere, all trying to reach the same critical systems, with no single office network to fall back on as a security perimeter.
We'd already done the hard part. Years back, we ditched VPN entirely for Zscaler's ZTNA product, ZPA. Granular, app-level access instead of flat network access, continuous posture checks on the endpoint, real zero-trust instead of the perimeter model VPN had been pretending to be. That part worked. I pushed hard for it when we went fully remote overnight and had basically zero visibility into what our own traffic was doing. It was the right call, and it's still the right call today.
The part that never worked was the other half: ZIA, the cloud forward proxy. It does three separate jobs. A client on the endpoint forwards traffic to the Zscaler cloud, the cloud does the TLS inspection, and the endpoint has to trust the certificate used to re-sign that inspected traffic. That design is exactly why it was the right tool for a remote workforce in the first place. No dependency on being behind an office network. That piece did what it was supposed to do.
Where it actually fell apart
Browser traffic, fine. The problem was everything else. Engineers run a long tail of CLI tools talking to cloud providers, databases, and the rest of a modern stack, and many of those tools handle certificate trust differently. Some use the operating system's trust store, while others need their own configuration, usually an environment variable or a tool-specific trust store. Multiply that across every tool and every engineer, and a five-minute fix on paper turns into a support burden nobody wants to own. Inspecting that traffic is possible. Doing it consistently, across every tool and every machine, and keeping it working as the tools update, is the operational problem.
Two different login flows for ZPA and ZIA didn't help either, people got confused constantly, and when someone got blocked they got zero explanation, just failure, with no way to tell if it was a posture problem or an access problem or what.
Data center routing added its own flavor of pain. In our experience, someone with a real gigabit connection could land on the proxy and see throughput far below what their line could do, which is what you'd expect when a shared service is carrying an entire remote workforce, and try explaining that nuance to someone who just wants their file to upload. The exact limits vary by vendor, plan and data center. Worse: geography got weird. When traffic exits from a proxy point of presence, the destination sees that location instead of yours, so geo-restricted sites could block people who were nowhere near the restricted region. Users landing at a point of presence in a different state or country than the one they were sitting in happened often enough to be its own recurring ticket category. How often depends on how a provider routes traffic and where its points of presence sit, so that's what we saw, not a rule about every deployment. None of it was a five-alarm fire. All of it added up to security spending more time defending the tool than anyone spent forgetting it existed, which is exactly backwards from how a security tool should feel.
Why Island, specifically
The ZTNA side is basically comparable to what we already had with Zscaler. The proxy side is where everything changed, and the proxy side was exactly what had been killing us.
The difference comes down to where the "last mile" is. It's a term from old telecom infrastructure, the final stretch of wire connecting a neighborhood backbone to your actual house, and historically the most expensive, failure-prone part of the whole network to build. Every model we'd used before, VPN, then ZIA, enforced policy somewhere upstream of you: a data center, a proxy hop, a point of presence. Your actual last mile, the real stretch between your laptop and the internet, sat outside whatever was making the security decision. That's a big part of why, for us, speed took a hit (your traffic took a detour to get evaluated before it could go anywhere) and why geography got weird (wherever that upstream hop happened to be became your effective location, not wherever you actually were).
Island moves much of the enforcement point to the actual last mile: the browser itself. Policy decisions happen right where you are, so traffic doesn't have to travel somewhere first, and your apparent location is much more likely to match your real one. Some traffic can still go through a cloud proxy when an application needs it, which I'll get to below.
It also just fixed a bunch of smaller annoyances at the same time. One login instead of two. Actual feedback when something's blocked instead of silence. For the handful of apps that genuinely need IP allowlisting, like some database services, Island still offers a cloud-proxy option that routes through their own points of presence, so we didn't lose anything, we just stopped needing it as the default.
Island doesn't make the CLI inspection problem disappear either. I asked their engineers directly, and the honest answer is you've got two broad options. Route traffic through their secure web gateway, which means funneling it through a central chokepoint again, the thing Island's architecture is built to move away from. Or go certificate-based, which puts you back in the world of getting the tools that don't use the operating system's trust store pointed at the right certificate, one tool and one person at a time. Neither is trivially easier than what we'd been trying to do with Zscaler. Both can inspect non-browser traffic. The hard part is the tradeoff between a central gateway and managing trust across individual tools, and doing it consistently at scale across developer tools that each handle trust differently.
How the rollout actually went
The rollout ran about six months end to end. Discovery and architecture review came first, then a proof-of-concept covering SSO, certificate logic, and traffic routing, the pieces that had to actually work before this got anywhere near real traffic. After that came persona-based proof-of-value and user acceptance testing alongside a risk and trade-off analysis, which is what turned this from an experiment into an actual recommendation to security leadership. Deployment readiness and testing against pilot groups followed, and then the rollout itself, staged across three waves until we were fully cut over off Zscaler.
Wave one was the technically fluent people first, for obvious reasons: the teams that needed direct cloud and Kubernetes access. Wave two was the teams that need to hit internal admin consoles and load unfamiliar external websites, exactly the traffic our old setup was worst at (Zscaler's domain-age heuristics loved blocking brand new sites outright, which is a great way to make those teams hate you). Wave three kept expanding to more teams, and we deliberately went after the stickiest, most annoying use cases we already knew about instead of saving them for later.
The policy model is simple in principle: application sensitivity and device trust decide the restriction. With an enterprise browser, the most sensitive applications can be limited to the managed browser itself, while lower-sensitivity applications stay open. A managed device can get full capability, copy, paste, the normal stuff. An unmanaged or personally owned device can still get access to what it needs, but data movement can be restricted through granular policy, rather than relying entirely on an all-or-nothing access decision, all enforced live through policy rather than some separate bolted-on control.
What broke, and what I'd actually do differently
This wasn't a clean one-to-one migration. Zscaler let us assign apps to a team and walk away. In our deployment, access policy had two separate layers to manage: who's allowed (an access profile tied to a group) and where the traffic actually routes (which servers handle it). We managed those layers independently, and they didn't stay in sync on their own. Someone authorized for a resource could get routed through servers meant for a different environment, and the connection just failed. Inconsistent wildcard usage during migration meant some of these mappings didn't line up. We fixed it in a few weeks by standing up an on-call bridge and pulling in the actual affected users alongside our engineers to build routing rules against real cases instead of guessing.
The problem I'd actually change process for is quieter: with a large number of policies and many people editing them, overlapping or conflicting entries are easy to create without anyone noticing, which is part of what we ran into. How the platform surfaces those conflicts is something I'd confirm with the vendor, but the lesson holds either way. If I ran this again, every category of config, access policies, posture profiles, the zero-trust rules themselves, gets a mandatory go/no-go review before launch. We learned the hard way that "our engineers are good, they probably did it right" is not a real control.
Where it landed
Adoption is effectively complete. The feedback's been unprompted, people randomly saying in Slack it's better than the old setup without anyone asking.
The ticket data backs some of this up, and complicates part of it. Zscaler-specific network and auth tickets dropped sharply after cutover. But Island brought its own wave of login and connectivity tickets in that same window, enough to offset a good part of the Zscaler drop, so total ticket volume didn't fall the way I'd have guessed going in. The one clean win nobody can argue with: setup and install friction, people not finding or being able to install the extension, disappeared within a few weeks. Island's own ticket trend has been heading down since, which is encouraging, but it's still early. Early signs of stabilization. Not a victory lap yet.
What is unambiguous: dual authentication is gone, one login instead of two. For browser traffic, the network round-trip through a data center is gone, so an entire category of "is it Zscaler" troubleshooting simply isn't a thing anymore. Administration is better too, not just for end users, our own engineers and admins running the platform day to day say it's faster and easier to manage.
The confusion under Zscaler wasn't actually a security problem, and I'm not going to dress it up as one. What it created was thrash: ZPA could de-authenticate while ZIA stayed up, or the other way around, and users had no way to tell a private app from a public one, so they'd just hit a wall with no idea why. That's friction, not a breach.
The real security upgrade is in how much more granular device trust can get. Not trusting network location was already a solved problem with a zero trust proxy. What an enterprise browser makes genuinely easier is tiering trust by device itself: fully managed machines still get vetted before touching anything sensitive, but personal and unmanaged devices, and partially trusted ones like an outside partner's, can connect to shielded resources with capabilities capped and actions limited, with data movement restricted through granular policy instead of an all-or-nothing gate. A proxy-based approach could technically support something like this, but building and maintaining it is hard enough that plenty of teams never do. An enterprise browser makes it easy enough that they do.
Consistent inspection of non-browser traffic is still the hard part of this architecture question, and I don't think any single product makes it cheap. But everything sitting around it got better, and I'd make the same call again.