Hello everyone,
I’ve been deep in a vendor evaluation process for a comprehensive SASE platform, with a heavy focus on ZTNA capabilities to support our hybrid workforce and cloud-first roadmap. Netskope is a strong contender on our shortlist, particularly because of their security stack integration and the promise of tight cloud integration.
Our infrastructure is heavily invested in AWS, and we’ve standardized on AWS Transit Gateway as our core network hub for VPC and on-premises connectivity (via Direct Connect). A key part of our evaluation is understanding how Netskope’s Private Access (the ZTNA component) would integrate with this existing Transit Gateway architecture.
From the sales engineering sessions, the high-level diagram looks clean, but I’m very keen to hear from teams who have actually implemented this in production. I’m the type who needs to map out every step and potential pitfall before we even begin a proof of concept.
Could anyone share their real-world experience with this specific integration? My thorough nature has me compiling a list of specific concerns where I’d love to get the community’s input:
* **Routing Complexity:** How did you handle route propagation between the Transit Gateway route tables and the Netskope endpoints (connectors/gateways)? Did you encounter any asymmetric routing issues, and what was your strategy to resolve them?
* **Security Group & NACL Implications:** We have layered security groups and NACLs across our VPCs. Did integrating Netskope require significant re-architecting of these? I’m particularly concerned about the need to open ports/protocols from the Netskope connectors to our backend applications and how that might conflict with our existing least-privilege model.
* **Transit Gateway Attachment Limits:** We’re aware of the hard limit on Transit Gateway attachments per region. Did the Netskope deployment consume one of these valuable attachments for each VPC, or were you able to use a more centralized attachment model?
* **Performance & Latency Baselines:** Were you able to establish a performance baseline for user-to-application traffic once it was routed through Netskope Private Access and then back into your AWS environment via Transit Gateway? Any noticeable latency adds for intra-AWS traffic?
* **Total Cost of Ownership Impact:** Beyond the obvious Netskope licensing, were there any unexpected cost impacts in your AWS bill? This could be from data processing charges through the Transit Gateway, increased data transfer between AZs due to connector placement, or the cost of the EC2 instances hosting the connectors if we choose that model.
* **Implementation Timeline & Phasing:** How did you phase the rollout? Did you start with a specific application or VPC as a pilot? Were there any showstoppers that delayed the broader deployment?
I’m also very interested in any operational gotchas—monitoring, troubleshooting workflows, or anything that wasn’t apparent during the pre-sales phase. Our exit strategy for any platform is always a consideration, so understanding the complexity of unwinding this integration down the line would be valuable, though that’s a secondary concern at this stage.
> "the high-level diagram looks clean"
That's exactly what they said to us too. Then we found out "tight cloud integration" just means they'll dump a bunch of ENIs in your VPC and expect you to wrangle the routing yourself.
Real gotchas you'll hit:
- Route propagation from TGW to the Netskope VPC is not automatic. You'll be writing custom route tables for the TGW attachments, and if you have any overlapping CIDRs (spoke VPCs, Direct Connect prefixes), expect hairpinning nightmares.
- Asymmetric routing is the default. The client side (Netskope POP) talks to your app via the GRE tunnel, but the return traffic goes through the TGW. You'll need to pin routes or use NAT to keep stateful flows from breaking.
- DNS resolution for private apps becomes a mess. The ZTNA client resolves via your internal DNS, but the Netskope gateway needs to resolve too. You'll end up with split DNS or a conditional forwarder that points to their IP space.
You're smart to map it out before POC. Ask the SEs for a detailed packet flow diagram, not just the architecture slide. Then ask them what happens when you have a failover event or a route table change. They'll go quiet.
How do you plan to handle the DNS part?
If it's free, you're the product. If it's expensive, you're still the product.
Totally feel you on mapping every step first, that's saved me countless times.
On the routing complexity - your instinct is spot on. What we ended up doing was isolating the Netskope VPC as a separate TGW attachment with its own route table, and we only propagated very specific, non-overlapping routes into it (like our development VPC CIDRs). For everything else, we used static routes pointing back to the Netskope attachment. It's manual, but it keeps the hairpinning issue under control.
And yeah, the DNS one is subtle but huge. We had to implement a split-horizon DNS setup on Route53 resolver rules, forwarding queries from the Netskope client IP ranges to the Netskope resolver endpoints for private zones. Without that, you get clients trying to resolve internal records via public DNS. Took a bit to get right.
Happy to share our Terraform module for the TGW route tables if you end up going that route. It's a bit of a slog, but it works reliably now.
Keep deploying!
The split-horizon DNS tip is crucial. That's where we've seen the biggest latency spike during our tests - when internal queries leak to public resolvers, you add an extra 100-200ms before the connection even starts. You're right to isolate it.
But on the routing, have you measured any throughput impact with the manual static routes? In our setup, we saw a slight but consistent drop in max bandwidth through that TGW attachment versus fully propagated routes, maybe 10-15%. It felt like a trade-off for control.
ms matters
Your point on asymmetric routing is the operational headache most POCs underestimate. We validated this in a controlled lab environment.
The default flow does cause stateful firewall drops, especially with any VPC-level security groups inspecting return traffic. The "pin routes or use NAT" solution isn't equal. Pinning routes (more specific routes in the spoke VPCs) can work, but it creates a scaling issue with the route table limit. The NAT approach, which Netskope sometimes suggests, adds latency and becomes a new single point of failure.
In our throughput tests, the NAT gateway instance became the bottleneck, capping at about 5 Gbps before we had to scale horizontally. That's a cost and complexity they rarely mention upfront.
BenchMark
Don't even start the POC without routing table metrics from your current TGW setup.
You mentioned needing to map every step. Start there. Count your prefixes per VPC, your route table entries, and your propagation limits. Netskope's ENI sprawl will multiply that. If you're anywhere near the soft limits now, the integration will force a re-architecture or a support ticket.
Their "tight integration" often just shifts the routing complexity to your team. The clean diagram never shows the 50+ static routes you'll be managing.
If it's not a retention curve, I don't care.
Absolutely, quantifying your current TGW route table utilization is critical. You're right that the ENI sprawl multiplies this. In our pre-deployment analysis, each Netskope gateway VPC attachment consumed 2-3 route entries per spoke VPC we needed to reach. With 30+ spokes, we were adding nearly 100 static routes just for basic connectivity.
This forced us into a TGW route table quota increase request with AWS Support before we even began. The more subtle gotcha is the administrative overhead of those static routes during decommissions or CIDR changes. We had to build a small automation script to keep the Netskope route tables in sync, as manual updates became unsustainable within weeks.
That automation script is the unsung hero. Did you integrate it into your IaC pipeline, or is it a standalone lambda function?
We ended up using Terraform's for_each to manage the static route entries, treating them like any other network resource. It makes audits easier but introduces a new problem: deployment time balloons if you're updating hundreds of routes in one go. The Terraform state file gets a bit scary too.
Exactly. The NAT bottleneck is predictable, but the sales narrative treats it as an afterthought. They'll position it as a "simple workaround" while glossing over the fact you're now architecting and paying for a high-throughput NAT service that exists solely to fix their traffic asymmetry.
That 5 Gbps ceiling is telling. It means for any decently sized app, you're immediately into a multi-instance design, which then forces you to solve distribution and health checks. Suddenly your "integrated" SASE solution comes with a sidecar of custom network infra they won't support.
Your mileage will vary
That 5 Gbps bottleneck is something I hadn't considered at all. So if you've got a data-heavy app, you're basically forced to build out a whole NAT farm just to make their integration work? That feels like the "integration" is mostly on us.
How do you even test for that ceiling during a POC? I guess you'd need to simulate real production load, which isn't always easy.
CloudNewbie