{"id":81779,"date":"2026-09-17T00:57:08","date_gmt":"2026-09-16T19:27:08","guid":{"rendered":"https:\/\/2thenew.online\/blog\/?p=81779"},"modified":"2026-10-27T23:05:00","modified_gmt":"2026-10-27T17:35:00","slug":"building-smarter-kubernetes-autoscaling-with-keda","status":"publish","type":"post","link":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/","title":{"rendered":"Building Smarter Kubernetes Autoscaling with KEDA"},"content":{"rendered":"<p>Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does not necessarily show the load that the application is facing especially if it is accessible via API or Web services.<\/p>\n<p>The application could experience a sudden increase in its traffic and yet the CPU would not have increased significantly. Additionally, response times could become slower by the application even when CPU and memory stay within acceptable levels.<\/p>\n<p>That is where we will require KEDA (Kubernetes Event-driven Autoscaling).<\/p>\n<p>Combining KEDA with Prometheus can provide a solution to scale applications using metrics other than resource usage.<\/p>\n<p>In this approach, four metrics are considered:<\/p>\n<ul>\n<li>CPU utilization<\/li>\n<li>Memory utilization<\/li>\n<li>Request rate<\/li>\n<li style=\"text-align: left;\">Request latencyThe first two represent resource utilization, while the latter two represent application-level behavior.<br \/>\n<hr \/>\n<\/li>\n<\/ul>\n<h1>Why Go Beyond CPU and Memory?<\/h1>\n<p>Consider an API service receiving increasing traffic:<\/p>\n<p>CPU\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a045%<br \/>\nMemory\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a055%<br \/>\nRequests\/sec\u00a0 \u00a0 \u00a0 250<br \/>\nP90 latency\u00a0 \u00a0 \u00a0 \u00a0 \u00a0750 ms<br \/>\nFrom a CPU and memory perspective, the application appears healthy.<\/p>\n<p>However, the latency indicates that users may already be experiencing slow responses.<\/p>\n<p>If the autoscaler only looks at CPU and memory, it may not scale the workload because neither resource has crossed its threshold.<\/p>\n<p>Application metrics provide another perspective:<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"alignleft wp-image-83551 size-full\" src=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54.png\" alt=\"Application load\" width=\"970\" height=\"381\" srcset=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54.png 970w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54-300x118.png 300w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54-768x302.png 768w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54-624x245.png 624w\" sizes=\"auto, (max-width: 970px) 100vw, 970px\" \/><\/p>\n<p>&nbsp;<\/p>\n<p>This makes the autoscaling decision more representative of the actual workload.<\/p>\n<hr \/>\n<h1>KEDA and Prometheus Architecture<\/h1>\n<p>KEDA works alongside Kubernetes HPA. Prometheus collects application metrics, KEDA evaluates those metrics, and the resulting scaling information is used by HPA to determine the desired number of replicas.<\/p>\n<p>A simplified architecture looks like this:<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-83552 size-large\" src=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM-683x1024.png\" alt=\"keda and prometheus archiecture\" width=\"625\" height=\"937\" srcset=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM-683x1024.png 683w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM-200x300.png 200w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM-768x1152.png 768w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM-624x936.png 624w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Aug-25-2026-05_42_48-PM.png 1024w\" sizes=\"auto, (max-width: 625px) 100vw, 625px\" \/><\/p>\n<p>&nbsp;<\/p>\n<p>The key advantage is that KEDA allows external metrics, such as Prometheus metrics, to participate in Kubernetes autoscaling.<\/p>\n<hr \/>\n<h1>Scaling Using Four Metrics<\/h1>\n<p>The implementation combines two Kubernetes resource metrics with two Prometheus application metrics.<\/p>\n<h2>CPU and Memory<\/h2>\n<p>CPU and memory remain useful because they indicate resource pressure inside the pods.<\/p>\n<p>For example, the CPU trigger can be configured with a target utilization of:<\/p>\n<pre>- type: cpu\r\n  metricType: Utilization\r\n  metadata:\r\n    value: \"70\"<\/pre>\n<p>Similarly, memory can use:<\/p>\n<pre>- type: memory\r\n  metricType: Utilization\r\n  metadata:\r\n    value: \"70\"<\/pre>\n<p>This gives us a baseline resource-based scaling mechanism.<\/p>\n<p>However, the more interesting part is the application-level metrics.<\/p>\n<h2>Request Rate<\/h2>\n<p>Instead of looking only at total requests, the request metric can be normalized by the number of ready pods.<\/p>\n<p>A generic Prometheus query looks like:<\/p>\n<pre>sum(\r\n  rate( \r\n    http_requests_total{\r\n      service=\"my-service\"\r\n    }[2m]\r\n  )\r\n)\r\n\/\r\ncount(\r\n   kube_pod_status_ready{\r\n     namespace=\"my-namespace\",\r\n     pod=~\"my-service-[0-9].*\",\r\n     condition=\"true\"\r\n  }\r\n)<\/pre>\n<p>The important concept here is:<br \/>\nTotal requests\/sec<br \/>\n&#8212;&#8212;&#8212;&#8212;&#8212;&#8212;<br \/>\nReady pods<\/p>\n<p>This gives an approximate requests-per-second-per-pod value.<\/p>\n<p>For example, if the application receives:<\/p>\n<p>10 requests\/sec<br \/>\nand has:<\/p>\n<p>2 ready pods<br \/>\nthen:<\/p>\n<p>10 \/ 2 = 5 requests\/sec\/pod<br \/>\nThis is more useful for capacity-based scaling than simply looking at the total request count.<\/p>\n<p>A target can then be configured, for example:<\/p>\n<p>1 request\/sec\/pod<br \/>\nThe actual threshold should be determined through load testing rather than choosing an arbitrary value.<\/p>\n<h2>Request Latency<\/h2>\n<p>The second application-level metric is latency.<\/p>\n<p>When Prometheus collects latency as a histogram, we can calculate a percentile using histogram_quantile.<\/p>\n<p>For example:<\/p>\n<pre>histogram_quantile(\r\n  0.90,\r\n  sum(\r\n    rate(\r\n      http_request_latency_ms_bucket{\r\n        service=~\"my-service\"\r\n      }[2m]\r\n    )\r\n ) by (service, le)\r\n)<\/pre>\n<p>This calculates the P90 latency.<br \/>\nIf the query returns: 100<br \/>\nand the underlying metric is measured in milliseconds, the P90 latency is: 100 ms<br \/>\nA threshold can then be configured at: 100 ms<\/p>\n<p>The purpose of using P90 rather than average latency is to capture the behavior of the slower portion of requests.<\/p>\n<p>For example:<\/p>\n<p>Average latency = 80 ms<br \/>\nP90 latency = 250 ms<br \/>\nThe average might suggest that everything is healthy, while P90 indicates that a significant portion of requests are considerably slower.<\/p>\n<hr \/>\n<h1>How KEDA Uses the Metrics<\/h1>\n<p>The four signals can be thought of as different indicators of application pressure:<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"size-large wp-image-83555\" src=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM-1024x683.png\" alt=\"keda metrics\" width=\"625\" height=\"417\" srcset=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM-1024x683.png 1024w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM-300x200.png 300w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM-768x512.png 768w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM-624x416.png 624w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_23_54-AM.png 1536w\" sizes=\"auto, (max-width: 625px) 100vw, 625px\" \/><\/p>\n<p>For example, consider:<br \/>\nCPU = 45%<br \/>\nMemory = 50%<br \/>\nRequest rate = 4 req\/sec\/pod<br \/>\nP90 latency = 180 ms<br \/>\nWith targets of:<\/p>\n<p>CPU = 70%<br \/>\nMemory = 70%<br \/>\nRequest rate = 1 req\/sec\/pod<br \/>\nP90 latency = 100 ms<\/p>\n<p>CPU and memory are within their targets, but both application-level metrics are above their configured thresholds.<\/p>\n<p>This gives the autoscaling system an indication that the workload may require additional capacity even though the traditional resource metrics do not show significant pressure.<\/p>\n<p>On the other hand, consider:<\/p>\n<p>CPU = 85%<br \/>\nMemory = 80%<br \/>\nRequest rate = 0.7 req\/sec\/pod<br \/>\nP90 latency = 90 ms<br \/>\nIn this case, traffic and latency look healthy, but resource utilization is high.<\/p>\n<p>The CPU and memory metrics provide the scaling signal.<\/p>\n<p>This is the main benefit of combining different types of metrics: <strong>different metrics can identify different types of workload pressure.<\/strong><\/p>\n<hr \/>\n<h1>Controlling Scale-Up and Scale-Down<\/h1>\n<p>Autoscaling is not only about deciding when to add pods. It is equally important to control how quickly pods are removed.<\/p>\n<p>KEDA allows the underlying HPA behavior to be customized.<\/p>\n<p>A typical configuration can use a relatively aggressive scale-up policy:<\/p>\n<pre>scaleUp:\r\n  stabilizationWindowSeconds: 30\r\n  policies:\r\n    - type: Percent\r\n      value: 100\r\n      periodSeconds: 15\r\n    - type: Pods\r\n      value: 2\r\n      periodSeconds: 15<\/pre>\n<p>This allows the application to respond quickly when there is a sudden increase in demand.<\/p>\n<p>Scale-down can be more conservative:<\/p>\n<pre>scaleDown:\r\n  stabilizationWindowSeconds: 60\r\n  policies:\r\n    - type: Percent\r\n      value: 100\r\n      periodSeconds: 15\r\n    - type: Pods\r\n      value: 1\r\n      periodSeconds: 60<\/pre>\n<p>The idea is simple:<br \/>\nScale Up \u2192 Fast response<br \/>\nScale Down \u2192 Controlled response<br \/>\nThis helps reduce the possibility of autoscaling flapping, where pods are repeatedly added and removed because of short-lived metric fluctuations.<\/p>\n<p>KEDA&#8217;s polling and cooldown settings also influence this behavior. For example:<\/p>\n<p>pollingInterval: 10<br \/>\ncooldownPeriod: 60<br \/>\nmeans KEDA evaluates external metrics at a relatively short interval while maintaining a cooldown period before scaling down.<\/p>\n<p>These values should be tuned according to the application&#8217;s traffic pattern and startup time.<\/p>\n<hr \/>\n<h1>Important Considerations<\/h1>\n<p>Using more metrics does not automatically mean better autoscaling. The metrics need to represent meaningful application behavior.<\/p>\n<h2>Choose thresholds based on testing<\/h2>\n<p>Suppose load testing produces:<\/p>\n<p>Traffic P90 Latency<br \/>\n&#8212;&#8212;&#8212;&#8212;&#8212;&#8212;&#8212;&#8212;-<br \/>\n10 req\/sec 60 ms<br \/>\n20 req\/sec 70 ms<br \/>\n50 req\/sec 95 ms<br \/>\n75 req\/sec 140 ms<br \/>\n100 req\/sec 220 ms<br \/>\nIf the target P90 latency is 100 ms, the application is already approaching its comfortable capacity around 50\u201375 requests\/sec.<\/p>\n<p>This information can help determine an appropriate request-rate-per-pod threshold.<\/p>\n<h2>Monitor downstream dependencies<\/h2>\n<p>Scaling application pods can also increase traffic to downstream systems:<\/p>\n<p>Application<br \/>\n\u2502<br \/>\n\u251c\u2500\u2500 Database<br \/>\n\u251c\u2500\u2500 Cache<br \/>\n\u251c\u2500\u2500 Message Queue<br \/>\n\u2514\u2500\u2500 External APIs<br \/>\nIf latency is caused by an overloaded database, simply adding application pods may not solve the problem.<\/p>\n<p>In some situations, it can actually make the problem worse by generating more database connections and queries.<\/p>\n<p>Therefore, autoscaling should be evaluated together with downstream metrics.<\/p>\n<h2>Configure a sensible replica range<\/h2>\n<p>A typical configuration might look like:<\/p>\n<p>minReplicaCount: 1<br \/>\nmaxReplicaCount: 10<br \/>\nThe actual values depend on application capacity and infrastructure limits.<\/p>\n<p>One important point is that if:<\/p>\n<p>minReplicaCount: 1<br \/>\nmaxReplicaCount: 1<br \/>\nthen horizontal scaling cannot occur regardless of how high the metrics become.<\/p>\n<p>The maximum replica count must therefore be greater than the minimum if actual autoscaling is required.<\/p>\n<hr \/>\n<h1>Monitoring the Autoscaling Behavior<\/h1>\n<p>A good monitoring setup should provide visibility into both the metrics and the scaling decisions.<\/p>\n<p>Useful metrics include:<\/p>\n<p>Application:<br \/>\n&#8211; Request rate<br \/>\n&#8211; P50 latency<br \/>\n&#8211; P90 latency<br \/>\n&#8211; P99 latency<br \/>\n&#8211; Error rate<\/p>\n<p>Kubernetes:<br \/>\n&#8211; CPU utilization<br \/>\n&#8211; Memory utilization<br \/>\n&#8211; Ready pods<br \/>\n&#8211; Current replicas<br \/>\n&#8211; Desired replicas<\/p>\n<p>Autoscaling:<br \/>\n&#8211; KEDA metrics<br \/>\n&#8211; HPA metrics<br \/>\n&#8211; Scale-up events<br \/>\n&#8211; Scale-down events<br \/>\nThis allows us to correlate an increase in traffic with the resulting scaling decision.<\/p>\n<p>For example:<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"size-large wp-image-83556\" src=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM-683x1024.png\" alt=\"metrics\" width=\"625\" height=\"937\" srcset=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM-683x1024.png 683w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM-200x300.png 200w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM-768x1152.png 768w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM-624x936.png 624w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_37_29-AM.png 1024w\" sizes=\"auto, (max-width: 625px) 100vw, 625px\" \/><\/p>\n<p>This is the behavior we ultimately want from an application-aware autoscaling system.<\/p>\n<hr \/>\n<h1>Conclusion<\/h1>\n<p>KEDA provides a powerful way to extend Kubernetes autoscaling beyond traditional CPU and memory metrics.<\/p>\n<p>By combining:<\/p>\n<p>CPU Utilization<br \/>\n+<br \/>\nMemory Utilization<br \/>\n+<br \/>\nRequest Rate per Pod<br \/>\n+<br \/>\nP90 Request Latency<\/p>\n<p>we can create an autoscaling strategy that considers both resource utilization and actual application behavior.<\/p>\n<p>CPU and memory tell us whether pods are under resource pressure. Request rate tells us how much traffic each pod is handling, while latency provides visibility into the application&#8217;s response time.<\/p>\n<p>The combination creates a more complete picture:<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" class=\"size-large wp-image-83557\" src=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM-819x1024.png\" alt=\"request flow\" width=\"625\" height=\"781\" srcset=\"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM-819x1024.png 819w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM-240x300.png 240w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM-768x960.png 768w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM-624x780.png 624w, https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/ChatGPT-Image-Sep-1-2026-11_42_23-AM.png 1122w\" sizes=\"auto, (max-width: 625px) 100vw, 625px\" \/><\/p>\n<p>The key to a successful implementation is not simply adding multiple metrics. The thresholds need to be defined based on load testing, production monitoring, and capacity management, along with accounting for downstream dependencies.<br \/>\nWith proper thresholds and scale-up\/scale-down behavior, KEDA can help to make the Kubernetes autoscaling very responsive to real application demand.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does [&hellip;]<\/p>\n","protected":false},"author":1936,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":0,"footnotes":""},"categories":[2348],"tags":[1217,1892,8859,3965],"class_list":["post-81779","post","type-post","status-publish","format-standard","hentry","category-devops-technology","tag-autoscaling","tag-devops","tag-keda","tag-kubernetes"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 5.0.0.1 - aioseo.com -->\n\t<meta name=\"description\" content=\"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Harsh Vardhan\"\/>\n\t<link rel=\"canonical\" href=\"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 5.0.0.1\" \/>\n\t\t<meta property=\"og:locale\" content=\"en_US\" \/>\n\t\t<meta property=\"og:site_name\" content=\"TO THE NEW BLOG\" \/>\n\t\t<meta property=\"og:type\" content=\"blog\" \/>\n\t\t<meta property=\"og:title\" content=\"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog\" \/>\n\t\t<meta property=\"og:description\" content=\"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/\" \/>\n\t\t<meta property=\"og:image\" content=\"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png\" \/>\n\t\t<meta property=\"og:image:secure_url\" content=\"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png\" \/>\n\t\t<meta name=\"twitter:card\" content=\"summary\" \/>\n\t\t<meta name=\"twitter:site\" content=\"@tothenew\" \/>\n\t\t<meta name=\"twitter:title\" content=\"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog\" \/>\n\t\t<meta name=\"twitter:description\" content=\"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does\" \/>\n\t\t<meta name=\"twitter:image\" content=\"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png\" \/>\n\t\t<script type=\"application\/ld+json\" class=\"aioseo-schema\">\n\t\t\t{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#article\",\"name\":\"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog\",\"headline\":\"Building Smarter Kubernetes Autoscaling with KEDA\",\"author\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/author\\\/harsh-vardhan\\\/#author\"},\"publisher\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/#organization\"},\"image\":{\"@type\":\"ImageObject\",\"url\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/wp-ttn-blog\\\/uploads\\\/2026\\\/09\\\/Screenshot-from-2026-08-25-11-46-54.png\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#articleImage\"},\"datePublished\":\"2026-09-17T00:57:08+05:30\",\"dateModified\":\"2026-10-27T23:05:00+05:30\",\"inLanguage\":\"en-US\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#webpage\"},\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#webpage\"},\"articleSection\":\"DevOps, Autoscaling, devops, KEDA, kubernetes\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#breadcrumblist\",\"itemListElement\":[{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog#listItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.tothenew.com\\\/blog\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/category\\\/devops-technology\\\/#listItem\",\"name\":\"DevOps\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/category\\\/devops-technology\\\/#listItem\",\"position\":2,\"name\":\"DevOps\",\"item\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/category\\\/devops-technology\\\/\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#listItem\",\"name\":\"Building Smarter Kubernetes Autoscaling with KEDA\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog#listItem\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#listItem\",\"position\":3,\"name\":\"Building Smarter Kubernetes Autoscaling with KEDA\",\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/category\\\/devops-technology\\\/#listItem\",\"name\":\"DevOps\"}}]},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/#organization\",\"name\":\"TO THE NEW Blog\",\"url\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/author\\\/harsh-vardhan\\\/#author\",\"url\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/author\\\/harsh-vardhan\\\/\",\"name\":\"Harsh Vardhan\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#authorImage\",\"url\":\"https:\\\/\\\/newersworld-sf-static.tothenew.net\\\/prod\\\/profilePicFolder\\\/94158b94-7876-492f-b1ba-69267bd5c8fd_Harsh-Vardhan-Profile-Pitcure.jpeg\",\"width\":96,\"height\":96,\"caption\":\"Harsh Vardhan\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#webpage\",\"url\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/\",\"name\":\"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog\",\"description\":\"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does\",\"inLanguage\":\"en-US\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/#website\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/building-smarter-kubernetes-autoscaling-with-keda\\\/#breadcrumblist\"},\"author\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/author\\\/harsh-vardhan\\\/#author\"},\"creator\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/author\\\/harsh-vardhan\\\/#author\"},\"datePublished\":\"2026-09-17T00:57:08+05:30\",\"dateModified\":\"2026-10-27T23:05:00+05:30\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/\",\"name\":\"TO THE NEW Blog\",\"inLanguage\":\"en-US\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.tothenew.com\\\/blog\\\/#organization\"}}]}\n\t\t<\/script>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog","description":"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does","canonical_url":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#article","name":"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog","headline":"Building Smarter Kubernetes Autoscaling with KEDA","author":{"@id":"https:\/\/2thenew.online\/blog\/author\/harsh-vardhan\/#author"},"publisher":{"@id":"https:\/\/2thenew.online\/blog\/#organization"},"image":{"@type":"ImageObject","url":"https:\/\/2thenew.online\/blog\/wp-ttn-blog\/uploads\/2026\/09\/Screenshot-from-2026-08-25-11-46-54.png","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#articleImage"},"datePublished":"2026-09-17T00:57:08+05:30","dateModified":"2026-10-27T23:05:00+05:30","inLanguage":"en-US","mainEntityOfPage":{"@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#webpage"},"isPartOf":{"@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#webpage"},"articleSection":"DevOps, Autoscaling, devops, KEDA, kubernetes"},{"@type":"BreadcrumbList","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog#listItem","position":1,"name":"Home","item":"https:\/\/2thenew.online\/blog","nextItem":{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog\/category\/devops-technology\/#listItem","name":"DevOps"}},{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog\/category\/devops-technology\/#listItem","position":2,"name":"DevOps","item":"https:\/\/2thenew.online\/blog\/category\/devops-technology\/","nextItem":{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#listItem","name":"Building Smarter Kubernetes Autoscaling with KEDA"},"previousItem":{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog#listItem","name":"Home"}},{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#listItem","position":3,"name":"Building Smarter Kubernetes Autoscaling with KEDA","previousItem":{"@type":"ListItem","@id":"https:\/\/2thenew.online\/blog\/category\/devops-technology\/#listItem","name":"DevOps"}}]},{"@type":"Organization","@id":"https:\/\/2thenew.online\/blog\/#organization","name":"TO THE NEW Blog","url":"https:\/\/2thenew.online\/blog\/"},{"@type":"Person","@id":"https:\/\/2thenew.online\/blog\/author\/harsh-vardhan\/#author","url":"https:\/\/2thenew.online\/blog\/author\/harsh-vardhan\/","name":"Harsh Vardhan","image":{"@type":"ImageObject","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#authorImage","url":"https:\/\/newersworld-sf-static.tothenew.net\/prod\/profilePicFolder\/94158b94-7876-492f-b1ba-69267bd5c8fd_Harsh-Vardhan-Profile-Pitcure.jpeg","width":96,"height":96,"caption":"Harsh Vardhan"}},{"@type":"WebPage","@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#webpage","url":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/","name":"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog","description":"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does","inLanguage":"en-US","isPartOf":{"@id":"https:\/\/2thenew.online\/blog\/#website"},"breadcrumb":{"@id":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/#breadcrumblist"},"author":{"@id":"https:\/\/2thenew.online\/blog\/author\/harsh-vardhan\/#author"},"creator":{"@id":"https:\/\/2thenew.online\/blog\/author\/harsh-vardhan\/#author"},"datePublished":"2026-09-17T00:57:08+05:30","dateModified":"2026-10-27T23:05:00+05:30"},{"@type":"WebSite","@id":"https:\/\/2thenew.online\/blog\/#website","url":"https:\/\/2thenew.online\/blog\/","name":"TO THE NEW Blog","inLanguage":"en-US","publisher":{"@id":"https:\/\/2thenew.online\/blog\/#organization"}}]},"og:locale":"en_US","og:site_name":"TO THE NEW BLOG","og:type":"blog","og:title":"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog","og:description":"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does","og:url":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/","og:image":"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png","og:image:secure_url":"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png","twitter:card":"summary","twitter:site":"@tothenew","twitter:title":"Building Smarter Kubernetes Autoscaling with KEDA | TO THE NEW Blog","twitter:description":"Kubernetes has the ability to offer a highly capable Horizontal Pod Autoscaler (HPA), which can be used to auto-scale the number of replicas according to the utilization of resources. In most instances, it is sufficient to consider only CPU and memory to perform this operation. Nevertheless, there might be instances when the resource utilization does","twitter:image":"https:\/\/2thenew.online\/blog\/wp-content\/themes\/ttn\/images\/social-logo.png"},"aioseo_meta_data":{"post_id":"81779","title":null,"description":null,"keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","local_seo":null,"limit_modified_date":false,"created":"2026-08-25 06:20:39","updated":"2026-10-27 17:35:03","focus_keyword":null,"additional_keywords":null,"truseo_locale":null,"ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"breadcrumb_settings":null,"seo_analyzer_scan_date":null},"aioseo_breadcrumb":"<div class=\"aioseo-breadcrumbs\"><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/2thenew.online\/blog\" title=\"Home\">Home<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/2thenew.online\/blog\/category\/devops-technology\/\" title=\"DevOps\">DevOps<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\tBuilding Smarter Kubernetes Autoscaling with KEDA\n\t\t<\/span><\/div>","aioseo_breadcrumb_json":[{"label":"Home","link":"https:\/\/2thenew.online\/blog"},{"label":"DevOps","link":"https:\/\/2thenew.online\/blog\/category\/devops-technology\/"},{"label":"Building Smarter Kubernetes Autoscaling with KEDA","link":"https:\/\/2thenew.online\/blog\/building-smarter-kubernetes-autoscaling-with-keda\/"}],"_links":{"self":[{"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/posts\/81779","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/users\/1936"}],"replies":[{"embeddable":true,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/comments?post=81779"}],"version-history":[{"count":23,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/posts\/81779\/revisions"}],"predecessor-version":[{"id":84082,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/posts\/81779\/revisions\/84082"}],"wp:attachment":[{"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/media?parent=81779"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/categories?post=81779"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/2thenew.online\/blog\/wp-json\/wp\/v2\/tags?post=81779"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}