My main use case for NGINX Ingress Controller has been in Kubernetes-based consulting work, especially when a team needs a controlled and observable entry point for application traffic.

In a typical setup, a user or client application sends a request to a public endpoint. That request first reaches an external load balancer, depending on the environment — for example, a cloud load balancer, MetalLB in a lab or bare-metal setup, or another external load-balancing layer. From there, the traffic is forwarded to the NGINX Ingress Controller running inside the Kubernetes cluster.

That is where NGINX Ingress Controller becomes important. It evaluates the Kubernetes Ingress rules, applies routing decisions based on hostnames and paths, and forwards the request to the right Kubernetes Service. The Service then sends the traffic to the correct backend pods, such as web pods, API pods, or authentication pods.

What I value most is that NGINX Ingress Controller is not just a way to expose services. It gives teams a practical control point for TLS termination, HTTP routing, rewrites, annotations, timeouts, security headers, rate limits, and observability. But it needs to be operated carefully. In production, the biggest risk is usually not NGINX itself, but weak configuration, missing monitoring, unclear ownership, or unsafe upgrades.

NGINX Ingress Controller helped by giving teams a predictable entry point for Kubernetes workloads. Instead of exposing services one by one, traffic could be routed through a controlled layer for TLS, host/path routing, rewrites, headers, logs, and metrics. The main benefit was operational clarity: better visibility, safer exposure of services, and fewer ad hoc networking decisions.

The best features are Kubernetes-native routing, TLS termination, flexible host/path rules, annotations, ConfigMaps, and observability when metrics and logs are configured well. In practice, it turns ingress into a clear control point for HTTP/HTTPS traffic. The trade-off is governance: annotations, rate limits, certificates, and upgrades need discipline.

I would improve diagnostics and guardrails. A built-in support bundle command that safely collects controller config, events, logs, versions, certificate status, and redacted error data would help teams troubleshoot faster. I would also like stronger policy controls around risky annotations, rate limits, TLS expiry, and upgrade validation. It should help security, but not pretend to replace Zero Trust or vulnerability management.

I have been using NGINX Ingress Controller for more than two years.

I consider it stable when deployed with disciplined configuration. In my experience, the controller itself is not usually the weak point. Problems tend to come from unclear annotations, certificate issues, poor observability, under-sized resources, or upgrades without staging. With good operational practices, it is reliable.

Scalability is strong because it fits naturally into Kubernetes. You can run multiple controller replicas, use resource requests/limits, autoscaling, and a load balancer in front of it. The important point is to test the whole path: controller capacity, backend services, TLS, rate limits, observability, and failure behavior under load.

My experience with support was mostly community/self-managed. In the environments I worked with, the client did not use NGINX Plus or premium support, so issues were handled through internal expertise, documentation, and consulting help when needed. For mission-critical production use, I would consider paid support or a supported controller path.

Yes. Before using NGINX Ingress Controller, I worked with more traditional network controls such as Layer 3 firewalls and manual routing rules. They were useful, but not enough for cloud-native workloads because Kubernetes needs application-aware routing by host, path, TLS, and service. That gap pushed me toward an ingress controller.

The initial setup is usually straightforward for a basic lab or small environment, but production setup is more complex. Installing the controller is not the hard part. The real work is DNS, TLS, load balancer integration, annotations, observability, resource sizing, security headers, staging, and upgrade/rollback discipline.

In the implementations I worked with, I did not rely on a dedicated integrator or reseller. The solution was deployed as part of the Kubernetes environment, and in one context it was obtained through AWS Marketplace. Most of the value came from internal/consulting implementation discipline rather than from a third-party integrator.

Yes. The ROI comes from reducing networking complexity and improving the safety of exposing Kubernetes services. Instead of handling every service separately, teams get a consistent ingress layer for TLS, routing, headers, logs, and metrics. The value is strongest when it prevents downtime, misrouting, expired certificates, or insecure exposure.

My experience was positive because the implementation I worked with was deployed as part of the Kubernetes stack, without premium NGINX support. That made the initial cost low. The real cost is operational: proper configuration, monitoring, certificate management, testing, upgrades, and people who understand Kubernetes ingress behavior.

I considered lower-level approaches such as iptables and traditional firewall/load-balancer rules. They can work, but they become hard to maintain as the number of services grows. NGINX Ingress Controller is easier to operate in Kubernetes because routing lives closer to the application model. The trade-off is that annotations and controller configuration must be governed carefully.

I would rate it 9/10 when it is operated intentionally. My advice is not to treat it as just a YAML shortcut. Use it with clear ownership, staging, controlled annotations, TLS monitoring, logs, metrics, resource limits, and rollback plans. For new designs or long-term roadmaps, also evaluate Gateway API or a supported controller path.

NGINX Ingress Controller serves our organization primarily for routing, SSL/TLS termination, and load balancing.

A specific example of how I used NGINX Ingress Controller for routing is that we define the paths and the applications inside the NGINX.conf. The traffic routes to the services, and we set up the load balancing at their own configurations level. Apart from that, we see limitations in NGINX Ingress Controller, as we have multiple services. We need to define the configurations in the annotation section, which causes a mess. Regarding SSL/TLS termination, since the traffic comes from outside to inside, the load balancer reads it out and redirects it to NGINX. We terminate that traffic at the NGINX configuration and then redirect the traffic to the services and ports without SSL/TLS. We used it for a long time before we shifted towards ALB for the last six months.

In my use case with NGINX Ingress Controller, when we have multiple services, it becomes messy and overburdened to add the annotations to define the policy and the annotations of each service, making it a bit complex. It is not straightforward. NGINX documentation is friendly and very handy, but with a large cluster, as we have a company running around 70 plus services, it is very difficult for us to manage these things.

NGINX Ingress Controller offers several best features, including SSL/TLS and flexible routing, which are the most powerful features. In the Ingress we define path-based routing, and we can define host-based routing; in NGINX, we can also define path-based routing and redirect to service level. The same applies to host-based routing in NGINX. The canary deployments feature allows us to shift a specific amount or percentage toward the new version when a new version is released. These are the very best features that I value in NGINX Ingress Controller.

My experience using canary deployments with NGINX Ingress Controller worked really well, by simply adding canary annotations in the NGINX sections, such as nginx.ingress.kubernetes.io/canary. When we define those annotations in the NGINX configurations, it works well. By adding those, we are able to route a specific percentage of traffic toward the new versions while keeping the remaining percentage on the stable version. This gives us confidence to release the new version without risking the entire user base. The setup is straightforward, though we had to manually monitor the canary traffic since there are no built-in analytics.

NGINX Ingress Controller has positively impacted our organization by efficiently routing the traffic. Previously, we were planning to move toward Traefik, but we see that NGINX is a widely used open-source controller that is easy to deploy in Kubernetes. NGINX documentation is very friendly, making traffic management easy. Managing load balancing configurations does not require significant effort, and deployments are smoother and faster. Managing SSL certificates is also simple. I think it has significantly impacted our organization.

NGINX Ingress Controller can be improved in multiple ways according to my suggestions. First, it takes time when we have many services, making routing complex. It is very difficult to manage the configurations using annotations, as we need to define the annotations of each service separately. A small mistake can break the whole routing policies and structure, making it challenging to debug deployments at large scale, which takes time. I also suggest integrating with Prometheus and Grafana for better visibility into traffic and performance. Overall, pairing NGINX with proper monitoring and GitOps practices makes it much more powerful and manageable.

From a security perspective, we can implement a WAF. That might work to tune the processes. For automation, adopting GitOps strategies instead of manual configurations can mitigate risks. These are improvements that can be added.

In my experience, NGINX Ingress Controller is very reliable and stable. It is very handy during our tenure with NGINX Ingress Controller, and it manages things easily. However, as I mentioned, with a very large cluster, it is challenging to spend time on adding and managing configurations. These are what I suggest could be improved in NGINX Ingress Controller, especially considering it is deprecated in March 2026.

I have been using NGINX Ingress Controller since I started my working profession when I used Ingress Controller in a Texan company, and then in this company, we are using Kubernetes. We deploy our applications on Kubernetes, and at that time we were using Ingress Controller for a long time. Then we decided that we should go with the ALB because we heard news that NGINX Ingress Controller is now deprecated and is going to be deprecated. We used it for one to two years.

NGINX Ingress Controller scalability is excellent. It is highly available and scalable, designed to manage high traffic in Kubernetes. The features include horizontal scaling, so we can scale the controllers by increasing the number of replicas in our deployments. It handles traffic effectively. Since my organization has a large cluster, we utilized this feature. The optimization is good, with a build on NGINX web binaries leveraging an asynchronous event-driven architecture that handles thousands of concurrent connections. The load balancing algorithm is supportive, with options such as round robin and least connections to distribute incoming traffic effectively across backend services.

Regarding customer support for NGINX Ingress Controller, I do not think we had a chance to sync with them. Given its high performance and dynamic reconfigurations, we handle it by our own expertise. We are using the community edition, which is open source, so support is primarily self-service via GitHub issues, Stack Overflow, or the Kubernetes Slack community. We did not get an opportunity to connect with customer support.

From my experience, if someone is a startup and does not want to spend money, I definitely recommend NGINX as a best option. For medium-tier companies also planning to implement an ingress controller, I think NGINX is the best for that. For enterprises seeking a cost-effective solution, NGINX is excellent in that case. The configurations, routing policies, and load balancing management are straightforward, so I highly recommend using NGINX. Additionally, since it has more features, we can implement management tools that do not require manually managing DNS records or SSL certificates. Fine-tuning performance is very good, as NGINX is fast, and the keep-alive feature reduces the overhead of TCP and TLS handshakes. Always set CPU and memory requests for your ingress to reduce throttling or OOM kills during traffic spikes. These are the recommendations I have.

It has been a great experience with NGINX Ingress Controller, and I am definitely looking forward to its return with new features and possibly a new name. We will certainly work with them. I would rate my overall experience with this product as an 8 out of 10.

NGINX Ingress Controller serves as the front door into our Kubernetes clusters that we use for databases. We run a bunch of internal, facing customer APIs and we need something that would do reliable routing without us handling configs and reloading them ourselves. We also lean on it for TCP and UDP load balancing through Transport Server. We have a couple of database-adjacent things like Postgres connection endpoints, a Redis service, and we want to expose them through it rather than standing up separate entities.

The decision to use NGINX Ingress Controller for those database-adjacent services, like the Postgres connection endpoints, is actually a big part of why I care about this working well. Transport Server is what we use to expose data services that are not HTTP. We have Postgres read-replica endpoints and Redis cache that we front through Transport Server for load balancing and TCP load balancing. The thing I always keep in mind is the connection draining and long-lived connections. Databases do not behave the same way as when you have a stateless server like stateless HTTP. A web request is done in fifty milliseconds; a Postgres connection might be open for hours. For example, MySQL has about eight hours for connections to be open until the engine kills them.

My main use case with NGINX Ingress Controller is focused on the connection side, where most of my scar tissue with this thing is. The core NGINX Ingress is fundamentally built around the HTTP request-response model. For connection pooling placements, I never let NGINX Ingress Controller manage database connection concurrency. We do have other connection poolers and load balancing. NGINX Ingress Controller is not a connection pooler; it does not understand the database protocol, transaction boundaries, prepared statements, or any of those sorts of things that a connection pooler manages. So in front of Postgres, we always run pgBouncer between the app and the database. The ingress is just doing some TCP load balancing to get to the pooler or the right replica. I think the mistake people make is thinking the ingress can take the place of a pooler, which it really cannot. It can, but it will just pass through every connection, and you will exhaust the max connections of the DB, even if you have set it to ten thousand.

The best feature that NGINX Ingress Controller offers for my use case is the Transport Server CRD and the dynamic reconfiguration offered with NGINX Plus. This is the number one feature by a wide margin for me. On Plus, endpoint changes update the upstream through the API without a config reload. For anything fronting a database or a connection pooler, this is the difference between rock-solid, long-lived connections and mysterious resets that you have every time a pod reschedules. Another thing is the policy CRD, rate limiting, and access control. This acts as protection for the data tier. You can put a rate limit at the ingress, so one misbehaving client cannot stampede a service and blow up the connection count, just trying to keep things managed and optimal.

This shift away from manual config management has made my team's productivity and efficiency much easier. There was real improvement, but I will be specific about where the speed came from because it is not where people usually assume. Before, exposing a new service or changing a route meant human editing NGINX config, getting it reviewed by whoever owned the edge, and a careful reload during a safe window. That was a ticket and wait process, realistically a day or more of latency for something trivial because it is queued behind whoever owned the config. For databases and data services, it is slower to stand up. Exposing a new Postgres endpoint or a pooler through Transport Server is not just a merge-it thing. It is deliberately so. It involves proxy protocol being wired end-to-end so we keep client attribution. Timeout settings are tuned way up so idle pooled connections do not get ripped. Health check semantics that actually mean something for a database rather than just a TCP connection, and capacity-wise, considering connection counts hitting max connection, it is just more complex with more things involved. The honest summary is that deployment of routing changes got much faster, mostly by removing the human bottleneck rather than any technical speed-up. Deployment of database exposure intentionally did not get faster, and should not, but it got reproducible, reviewable, and instantly revertible. So when you make them, you are able to take them back. For the data tier, the reliability gain mattered far more than raw speed ever would have.

NGINX Ingress Controller can be improved, and my team's concern would be database protocol-aware health checks for Transport Server since that is what NGINX is more focused on. Right now, even on Plus, a Transport Server health check is essentially a TCP connect or maybe a basic send-expect. For a database, that is a weak signal. The listener being up tells you almost nothing about whether Postgres is actually serving, whether a replica is lagging, or whether it is in recovery. I would love a way to define a health check that does something protocol-aware, even something as simple as you open a connection, run a SELECT one, which is the most popular test, and expect a row for Postgres or a PING for Redis. Without that, I am relying on the database's own infrastructure to pull bad replicas, and the ingress will happily continue routing to a replica that answers TCP but is serving stale reads. Better idle connection management for long-lived stream connections can also be improved. A pooled database connection sitting idle between transactions is healthy in my opinion, but the proxy's instinct is to reap idle connections. You can crank timeouts way up, but that is a blunt instrument.

I would like to add that specifically for databases, the need for improvement becomes clearer. Every client connection through NGINX becomes a backend connection, one-to-one. A client connection through NGINX and a client connection through a connection pooler are sitting because they are going to get sent to the backend connection. It does not multiplex; it does not understand transaction boundaries. It cannot reuse a connection across clients. If you put it in front of Postgres without a real pooler behind it, you have just built a very efficient way to exhaust the max connection. The architecture is always client, ingress, connection pooler which is either pgBouncer or ProxySQL, then the actual engine which is Postgres or MySQL. Never let it be clients straight to the database. NGINX Ingress Controller's mode is one client connection to one backend connection with no multiplexing and no protocol awareness, which would be an issue for you.

I have been using NGINX Ingress Controller for three years now.

NGINX Ingress Controller is stable, and I would say there are different stability stories when talking about how it behaves in front of databases. NGINX Ingress Controller is stable itself. NGINX's data plane is rock solid. I do not really experience any reliability issues.

For scalability, HTTP scales very well horizontally. It is straightforward. More controller pods behind the LB, and NGINX handles higher requests and connection volumes per pod efficiently. It scales really well.

For NGINX Ingress Controller's customer support, I experience community support for the open-source side which means GitHub issues, project documentation, Slack, and community channels. On NGINX Plus side, there is paid commercial support. They are obviously available to help with issues that I have, and I have encountered great engineers. Overall, it is a great experience.

I have seen a return on investment, but I do not have the actual numbers. The return is an avoided cost story, not a revenue or savings line. The clearest return is incidents that stopped happening. We used to have multiple incidents, but they stopped happening before we moved data tier parts to NGINX Plus. We had a recurring category of incidents. I would not say fewer employees; I would push back on that being the sense of it. NGINX Ingress Controller's ROI is real, but that is all I have to say, to be honest.

I do not have much to say on the pricing, setup cost, and licensing front. There is a different functional team for managing costs and licensing in the environment. I can say a few things from my experience, though. The core dynamics and core features for databases involve the paywall. The paywall is what concerns me. I am not really sure about every other cost, but the decision lies with the other functional team.

Before NGINX Ingress Controller, we came off community ingress NGINX, and before that, plain HAProxy managed by hand for the database parts. We evaluated a few solutions such as HAProxy, ingress, Traefik, and Envoy. The decision came down to CRD-based config ownership plus a paid escape hatch for the reload problem on the database parts. This is purely a review based on its interaction with databases. The platform engineering team uses NGINX Ingress Controller for various important aspects of covering all of the tech platform and services that we manage.

My advice for others looking into using NGINX Ingress Controller, especially for the database side of things, is to be aware that the ingress is deliberately a stateless system. Every problem you will have comes from forgetting something. Internalize that the ingress does not understand the database. Never let it act as a connection pooler. Always put a real pooler behind it. The architecture is always client, ingress, your connection pooler which is either pgBouncer or ProxySQL, then your actual engine which is Postgres or MySQL. Never let it be clients straight to the database. NGINX Ingress Controller's mode is one client connection to one backend connection with no multiplexing and no protocol awareness, which would be a major issue for you. I have given this product a rating of seven out of ten.

Our main use case for NGINX Ingress Controller is that we are using it in our EKS and our open source Kubernetes as a controller where it handles our traffic.

A specific example of how we use NGINX Ingress Controller to handle our traffic is that we are configuring the Kubernetes cluster as a private endpoint only, so it will not be accessible through the internet for anyone. We are securing it through a private endpoint only, so we are using NGINX Ingress Controller for handling the traffic. We are configuring NGINX Ingress Controller as pods, and then we are configuring the Ingress rules for that to serve which traffic is coming from the load balancer and to where the traffic will be routed. We are configuring the Ingress rules based on the rules, and it will route to the different services, and from the services, it will route to the different pods and deployments. Using that, we will configure the SSL certificate for the security, and in NGINX Ingress Controller only, it will handle the certificate termination. SSL termination will happen within the controller. It is very reliable for us.

The best features NGINX Ingress Controller offers include SSL termination, where it handles the certificate terminations, and if I had to pick a favorite feature, that would be it.

NGINX Ingress Controller has positively impacted our organization by improving security when it comes to the certificate. As I mentioned, SSL termination is one of the points where it improves. When it comes to handling the traffic, where we are configuring the Ingress rules, we can say that it is very highly improved for us. Even though the traffic is very high, it will be handled very well, routing the traffic based on the Ingress rules to the particular service and to the particular pod.

When it comes to how NGINX Ingress Controller can be improved, I think we can add documentation as one of the points. We can improve it so that everyone can directly refer to the particular document in a precise way, and we will be getting very specific information. When we have any specific issues, it will be much easier for us to troubleshoot things. Documentation is one of the points, and everything is so far good for me.

We are using NGINX Ingress Controller for the past two to three years.

NGINX Ingress Controller is stable and has been reliable for me over time.

NGINX Ingress Controller's scalability is good and can handle increased load easily.

The customer support for NGINX Ingress Controller is good; I have reached them a few times, and it was good.

I did not evaluate other options before choosing NGINX Ingress Controller.

The advice I would give to others looking into using NGINX Ingress Controller is that we are using this for the past three to four years, and it is very reliable for us and it can handle the traffic based on our load as well. So I can suggest it to them when they are starting with new clusters and thinking to opt for any controllers for their cluster. I can directly suggest it. I would rate this product an 8 out of 10.

My main use case for NGINX Ingress Controller is that I commonly use it as a reverse proxy.

I have used NGINX Ingress Controller for SAP API calls, so whenever I am using these API calls on my frontend application, I don't want to expose the SAP server details. Therefore, I normally ingress it through NGINX Ingress Controller, mapping all these APIs to the SAP APIs, and from the frontend, I have access to it as a local post, effectively hiding all the SAP server URLs. A specific use case includes sales order APIs and posting something into SAP to get the business partner details from SAP, and similar actions.

NGINX Ingress Controller offers primarily reverse proxying capabilities, and the proxy feature stands out for me due to some performance benefits, definitely security as the first thing, and also the load balancing aspect and the ability to route traffic to multiple servers.

NGINX Ingress Controller has positively impacted my organization by definitely improving my team's efficiency in terms of multiple load balancers and complex routing rules we can configure there, resulting in a single, easy-to-manage layer. Hence, routing, SSL termination, and rate limiting contribute to making us much faster and efficient.

NGINX Ingress Controller can be improved by implementing faster deployment of new services, simplifying SSL or TLS management, and enhancing faster troubleshooting by providing more logs. While I have debug logs, using more techniques to reduce the mean time to resolution would be beneficial.

I have been using NGINX Ingress Controller for ten years.

NGINX Ingress Controller is stable.

In the Kubernetes environment, NGINX Ingress Controller scales very well.

As a developer, I can definitely say that NGINX Ingress Controller improves performance in terms of load balancing, especially in a microservices environment with many APIs. I don't have closely related metrics, but in a past microservices environment where I had fifty or more services, maintaining around one thousand to one thousand five hundred APIs was very hard without ingress. However, with ingress, it is easier to maintain them, and I think it doesn't charge more than thirty dollars a month for usage.

NGINX Ingress Controller is pretty standard and very lightweight, making it highly recommendable to use in local development environments, and it is especially useful in test environments for enabling SSL and rate limiting.

On a scale of one to ten, I would rate NGINX Ingress Controller around eight point five, near to nine, due to the ease of setup, although there is a slight learning curve with some advanced features. The documentation is good and reliable, and it performs well as it is lightweight and handles traffic loads sufficiently. While debugging, the logs are generally helpful, debugging complex routing can sometimes be tricky, so I may need to have more NGINX internals to be logged. Overall, scalability, performance, and upgrades are all good, and using it in Kubernetes integrates very well.