Skip to content
Notifications
Clear all

Guide: How we use NordLayer to segment support vs engineering network access.

32 Posts
32 Users
0 Reactions
452 Views
(@davidh)
Honorable Member
Joined: 4 months ago
Posts: 410
Topic starter   [#25399]

Within our organization, we've long operated under a flat network security model, granting all technical staff broad access to our development and staging environments. While operationally simple, this presented significant risks from a least-privilege standpoint. A support engineer troubleshooting a user-facing issue should not have the same network-level access to backend databases and CI/CD control planes as a software developer.

We implemented NordLayer to enforce network segmentation between our Support and Engineering teams, moving beyond a single VPN gateway. The goal was to create distinct, policy-based access zones without overhauling our core cloud VPC architecture. Here is our detailed configuration.

**Architecture Overview**

We maintain two primary virtual private clouds (VPCs) in AWS:
* `vpc-app-staging`: Contains customer-facing application replicas, support tooling, and read-only database replicas.
* `vpc-engineering`: Hosts primary databases, Kubernetes control planes, CI/CD servers (Jenkins), and internal monitoring systems.

NordLayer allows us to create separate "Virtual Gateways" that act as ingress points into these VPCs. We then route specific subnet traffic through these gateways.

**Gateway and Route Configuration**

We created two NordLayer Virtual Gateways:
1. `gateway-support-us-west-2`
2. `gateway-engineering-us-west-2`

Each gateway is configured with a unique IP range (e.g., `10.7.0.0/16` for support, `10.8.0.0/16` for engineering). The critical step is configuring route tables within our AWS VPCs to direct traffic sourced from these IP ranges appropriately.

The `vpc-app-staging` route table has a route allowing `0.0.0.0/0` to the `gateway-support-us-west-2` via a VPN connection (established using NordLayer's provided configuration). More importantly, the `vpc-engineering` route table uses more specific routes:

```json
// Example of a CloudFormation snippet for the engineering VPC route table
Routes:
- DestinationCidrBlock: "10.7.0.0/16" // Support Team IP Range
GatewayId: !Ref InternetGateway // Route to IGW, NOT the VPN
- DestinationCidrBlock: "10.8.0.0/16" // Engineering Team IP Range
VpcPeeringConnectionId: !Ref NordLayerVPNConnection // Route via VPN
- DestinationCidrBlock: "10.0.0.0/8" // Internal VPC Traffic
VpcPeeringConnectionId: !Ref NordLayerVPNConnection
```

This configuration ensures that:
* Support team members (IP range `10.7.0.0/16`) connected to `gateway-support` can reach `vpc-app-staging` but are explicitly routed *out* to the public internet when attempting to access `vpc-engineering`, resulting in blocked connection attempts (unless a service is publicly exposed).
* Engineering team members (IP range `10.8.0.0/16`) connected to `gateway-engineering` have routes into both VPCs via the VPN.

**Client Configuration and Deployment**

Team members use the NordLayer application. Access is controlled via NordLayer Teams groups:
* `group-support`: Assigned to the `gateway-support` gateway configuration file.
* `group-engineering`: Assigned to the `gateway-engineering` gateway configuration file.

The configuration files are distributed via our MDM (Jamf). This ensures zero configuration effort for end-users; they simply activate the NordLayer client and are placed into the correct network segment.

**Observability and Cost Implications**

We integrated NordLayer's connection logs with our SIEM (Sumo Logic) to monitor connection attempts and anomalies. A key cost optimization was realizing that NordLayer's "Virtual Gateway" pricing is per-gateway, not per-connected user. Therefore, scaling the number of support or engineering staff does not increase cost, only the addition of new gateways (e.g., for a separate data science environment) would.

**Pitfalls and Considerations**

* **DNS Resolution:** We had to configure split-brain DNS. Internal domain names (e.g., `db.internal`) must resolve to private IPs for the engineering gateway but will fail to resolve or resolve to public endpoints for the support gateway. This is handled by private Route53 zones associated with each VPC.
* **Latency:** The intermediary NordLayer gateway adds ~8-12ms of latency compared to a direct VPC VPN. This is acceptable for SSH and database connections but was a consideration for some low-latency tooling.
* **Service-Specific Rules:** This network-layer segmentation is a foundation. We complement it with application-layer authentication (e.g., IAM roles for databases, RBAC in Kubernetes) for defense in depth.

The implementation has successfully contained lateral movement following a hypothetical credential compromise of a support tool and has satisfied several compliance framework requirements regarding access segregation.


Data over dogma


   
Quote
(@bobw)
Reputable Member
Joined: 4 months ago
Posts: 342
 

I'm a lead developer at a mid-sized fintech, running our API and automation platform where we manage segmented access for internal tools, vendor integrations, and client webhooks, all on a hybrid AWS/GCP setup.

* **Deployment speed vs. granularity**: NordLayer got us a segmented network in about two days because it's essentially a policy-managed VPN overlay. The trade-off is you're not getting true microsegmentation at the workload level. In our case, defining access by team subnet (e.g., `10.10.20.0/24` for support, `10.10.30.0/24` for engineering) was enough, but if you need individual instance-level rules, you'll still need security groups or a service mesh.
* **Cost clarity for team-based access**: Pricing is per seat, and at my last shop we paid $7/user/month on the Business tier. The predictable cost was a win for budgeting, but watch your connector count. Each virtual gateway (like the OP's separate gateways per VPC) is a connector, and you only get 20 on that plan. If you later need a gateway per region or per environment, you can hit that limit.
* **Operational simplicity with a key constraint**: It truly shines for human access from laptops. The apps work well. Where it doesn't apply is server-to-server traffic. We initially tried to route some automated backup jobs through it and saw a 30-40% throughput drop versus a direct VPC peering link. It's not built for that.
* **Support experience for urgent issues**: We had an incident where a config push locked out a team. Their live chat had a tech on in under 5 minutes, and they fixed a routing table error on their gateway side in about 20. For platform issues, they're responsive. For architectural advice on your specific cloud setup, they'll point you to docs.

I'd recommend NordLayer specifically for the use case you described: quickly enforcing team-based network zones for human access to existing cloud environments. If your constraints allow a coarser, subnet-level segmentation and your traffic is primarily engineers and tools from their workstations, it's a great fit. To make a totally clean call, tell us the total number of distinct network zones you'll need in 12 months and whether any critical daily workflows involve automated, server-originated traffic between those zones.


null


   
ReplyQuote
(@franklin77)
Reputable Member
Joined: 4 months ago
Posts: 285
 

You've nailed the operational trade-off. It's a team-level access tool, not an infrastructure one.

The connector limit is a critical catch that isn't obvious at the start. Hitting that 20 connector ceiling on the Business plan forces a costly upgrade or a messy architectural compromise. I've seen teams try to work around it by routing multiple environments through a single gateway, which completely undermines the segmentation goal.

Your point about it being for human access from laptops is exactly right. It falls apart for any automated system-to-system traffic or if you need to onboard a temporary contractor's virtual machine. You still need a separate solution for those use cases.


Trust but verify — especially the fine print.


   
ReplyQuote
(@anikap)
Trusted Member
Joined: 4 months ago
Posts: 88
 

The connector limit is a really good callout, especially for larger teams. I was looking at their pricing page just yesterday and you're right, that 20 connector cap on the Business plan is easy to miss.

My main question is about how they define a "connector" for billing. Is it strictly one per user device, or could a single user with a laptop and a phone count as two? That kind of ambiguity can turn a predictable per-seat cost into a surprise.



   
ReplyQuote
(@averyk)
Honorable Member
Joined: 4 months ago
Posts: 523
 

Great question. Their documentation calls it a per-license model, but in practice a license ties to a single user account, not a device. That one user can be connected on multiple devices simultaneously.

So a user with a laptop, phone, and maybe a home desktop would still only consume a single connector seat. The limit is really about concurrent, distinct user identities needing active network gateways. It's still a sharp edge for scaling teams, but at least the per-device worry isn't the issue.


Review first, buy later.


   
ReplyQuote
(@eval_engineer_101)
Reputable Member
Joined: 4 months ago
Posts: 283
 

Interesting approach. How does using NordLayer's virtual gateways to route into specific VPC subnets compare to just setting up traditional VPN servers, like OpenVPN, on a bastion host in each VPC? Does the managed service reduce the maintenance overhead enough to justify the per-seat cost, or is the main win just the centralized policy management?



   
ReplyQuote
(@amandaf)
Reputable Member
Joined: 4 months ago
Posts: 455
 

The main win is absolutely the centralized management. With self-hosted OpenVPN instances, every team subnet requires its own server setup, certificates, and config updates. NordLayer replaces that with a single dashboard to define groups and routes.

Whether it justifies the cost depends on how you value your team's time. The per-seat fee isn't just for the gateway software, it's for the abstraction layer that lets a non-network engineer update access in five minutes. If you have a dedicated infra team that enjoys maintaining a fleet of VPN servers, the trade-off might not be worth it. If you don't, the operational savings are significant.

Your bastion host approach works, but you're then responsible for patching, monitoring, and scaling those hosts. For a lot of teams, offloading that to a vendor is the entire point.


—AF


   
ReplyQuote
(@daisym)
Reputable Member
Joined: 4 months ago
Posts: 226
 

That's such a clear breakdown of your architecture. I love the use of read-only replicas in the `vpc-app-staging` for support. We did something similar for our customer success team, but we also put the error tracking and observability dashboards (like Datadog) there too. It gave them incredible context without ever touching a production system.

We found the real magic was in those small, well-defined subnets. When everything is carved up cleanly, writing the NordLayer routing rules becomes almost trivial. Did you run into any challenges with services that needed to talk across those VPC boundaries after the split?



   
ReplyQuote
(@amyw)
Honorable Member
Joined: 4 months ago
Posts: 427
 

Love that setup with separate VPCs. We took a similar path but started with subnets in a single VPC for staging and engineering. The moment you define those clean subnets, the NordLayer rules just click into place.

We did hit a snag with our CI/CD system, though. Some build jobs needed to pull artifacts from the staging subnet, which broke after the split. We had to set up a specific, locked-down "bridge" route for that traffic in NordLayer, which added a bit of config but kept the segmentation intact. Did you encounter anything similar with cross-VPC service dependencies?


measure twice, ship once


   
ReplyQuote
(@carols)
Estimable Member
Joined: 4 months ago
Posts: 142
 

That's a common issue. We faced a similar challenge with our internal package repository, which was hosted in the engineering subnet but needed to be accessed by automated deployment runners in a separate, more restricted subnet.

The locked-down bridge route is the correct approach, but it's worth formalizing that as a policy. We created a dedicated "Service Bridge" team in NordLayer with a static, tiny IP range (like a /29) and attached routes only to the specific destinations needed (e.g., the artifact store IP, the package repo). No team members are assigned to it; it's only used as a target for the CI system's gateway. This keeps it from becoming a general bypass.

Did you find the bridge route management became cumbersome as the number of cross-segment dependencies grew? We started documenting each one as a ticket in our infra change log to track the blast radius.


Buy once, cry once.


   
ReplyQuote
(@emilyl2)
Reputable Member
Joined: 4 months ago
Posts: 219
 

The dedicated "Service Bridge" team with no users is a really clever way to handle it. I wouldn't have thought of that.

I'm just starting to set up our segmentation, so I haven't hit that scaling issue yet. Does documenting each bridge route as a ticket actually help when something needs to change, or does it just become more overhead?



   
ReplyQuote
(@annad)
Reputable Member
Joined: 4 months ago
Posts: 343
 

That "Service Bridge" team pattern is a lifesaver for keeping automation secure and trackable.

On your question about documentation: making a ticket for each route felt like overhead at first, but it pays for itself the first time a service needs to be decommissioned or a security audit happens. We use a simple tag in the ticket (like `#network-bridge`) and link it to the NordLayer rule name. Without that, you end up with "ghost" routes that nobody remembers the purpose of.

The trick is to keep the process lightweight. If your ticketing system is heavy, even a shared document with a table can work. The goal is just to answer "why does this route exist?" six months from now. How does your team usually track this kind of infrastructure change?



   
ReplyQuote
(@baller_analytics)
Honorable Member
Joined: 5 months ago
Posts: 483
 

You gloss over the main cost. You now have two gateways to monitor and secure instead of one. It doubles your attack surface.

What's your actual incident rate for support staff accessing engineering systems? If it's zero, you just bought a solution for a problem you didn't have.

The VPC split is good. The managed VPN for it is debatable.


If it's not a retention curve, I don't care.


   
ReplyQuote
(@charliep)
Prominent Member
Joined: 4 months ago
Posts: 803
 

> "The goal was to create distinct, policy-based access zones without overhauling our core cloud VPC architecture."

You're still overhauling it. You've created two new gateways and likely a dozen new routing rules. That's an architecture change, you're just using a vendor abstraction to do it.

And if your goal was least-privilege, why not start with IAM and security groups? A VPN is a network-level key to the whole house. If your real problem was support engineers querying prod databases, the fix is database permissions, not a new VPC.

This feels like you bought the tool, then went looking for the justification.


Your stack is too complicated.


   
ReplyQuote
(@emilyk22)
Honorable Member
Joined: 4 months ago
Posts: 465
 

That's a solid foundation, and your two-VPC approach mirrors the logical separation that's often hardest to get right.

Your point about "without overhauling our core cloud VPC architecture" is key, as some comments seem to miss the operational reality. For teams without dedicated network engineers, restructuring VPC peering, route tables, and security groups across an existing estate *is* an overhaul. Using NordLayer to define access at the gateway level, on top of an already sensible VPC split, is often the most pragmatic path to least-privilege.

I'm curious about your subnet routing strategy within those VPCs. Did you find it necessary to further segment within, say, `vpc-engineering` using NordLayer routes, or are internal security groups handling the finer-grained controls between, for example, CI/CD servers and primary databases?


Support is a product, not a department.


   
ReplyQuote
Page 1 / 3