mrkeyoor.comAsk

kedacore/kedatested 01 Oct 2026commit 81c6b83

keda review

KEDA is worth evaluating when event-driven Kubernetes scaling, including activation from zero, is the requirement.

  • Install 105 s
  • Build 466 s
44/53passed, run exited non-zero
  • 759 packages
Automationevaluationupdated 31 Oct 2026
+5stars / 7d

Choose KEDA when Kubernetes workloads need event-driven scaling, including scaling to and from zero, and your team can validate that behavior against its event source. KEDA integrates with the Horizontal Pod Autoscaler rather than replacing it. Our run on October 1, 2026, at commit 81c6b83 recorded successful install and build steps, but the test command failed. It did not establish that a deployed workload could scale correctly.

Verdict

KEDA is worth evaluating when event-driven Kubernetes scaling, including activation from zero, is the requirement. Our October 1, 2026 run at commit 81c6b83 completed the recorded install and build steps but failed its test command. Investigate the named failures and validate a representative workload in staging before relying on its scaling behavior. Consider Knative Serving for serving primitives, or Prometheus Adapter when exposing Prometheus metrics to HPA is the requirement.

We ran it

Lab card: what happened when we ran keda
Lab card from our sandbox run
Screenshot of keda (keda.sh)
keda.sh
Install✓ · 105s759 packages
Build✓ · 466s
Tests✗ · 544s44 passed · 9 failed of 53 (go test)
Repo787 files~190,507 lines of source · 9.4 MB · 22 CI workflows · Dockerfile · tests dir

Answers from our run

Does keda build from source?

Dependencies installed in 105 seconds (759 packages), and the build succeeded in 466 seconds. We cloned commit 81c6b83 into a clean Debian container with 3 CPUs and no project-specific setup.

Do keda's tests pass?

No. The project's own test command finished in 544 seconds and reported 44 passed, 9 failed (go test).

Who should not use keda?

Teams looking for an autoscaler outside Kubernetes.

What are the alternatives to keda?

Knative Serving, Prometheus Adapter. KEDA is worth evaluating when event-driven Kubernetes scaling, including activation from zero, is the requirement.

Setup2/5On the visible prerequisite-based rubric, the successful build is offset by required cluster components and certificates, plus a failed sandbox test command.
Docs5/5On the visible documentation-scope rubric, the supplied README, build guide, and testing strategy cover deployment, local development, debugging, and testing.
Community5/5On the visible participation-route rubric, the README documents meetings, Slack discussion, contribution, and governance. Response times, adoption, and current activity were not measured.
Maturity5/5On the visible governance-and-testing rubric, documented CNCF graduated status and cluster-based end-to-end infrastructure support this assessment; it is not scaler certification.

Who it’s for

Kubernetes operators evaluating event-driven scaling for a specific workload.
Platform teams prepared to configure Kubernetes custom resources and validate the event source used for scaling.
Contributors who can investigate sandbox test failures and reproduce cluster-dependent behavior in an appropriate environment.

Who it’s NOT for

Teams looking for an autoscaler outside Kubernetes.
Readers who need this review to prove production scaling behavior, activation latency, or event-source compatibility: our run did not test those outcomes.
Teams seeking a serverless serving layer with routing and deployment snapshots; Knative Serving addresses that broader serving requirement.

Setup reality

Our run on October 1, 2026, at commit 81c6b83 used a sandbox with 3 CPUs, 8 GB RAM, and the golang:1.24-bookworm image. The install step completed in 105 seconds, the build step in 466 seconds, and the test command exited 1 after 544 seconds. The install tail records a Go 1.26.0 download, so the image name alone does not establish the toolchain used throughout the run.

The stored parser summaries report 44 passed and 9 failed, totaling 53. These are parsed package outcomes, not a verified count of unique individual tests or exhaustive coverage. The dependency record contains 759 packages; that is separate from the test summary.

The raw excerpt identifies TestAPIs failures in two API packages and the controller package, a panic marker, and a failure in pkg/scalers. It does not provide enough detail to diagnose their causes. Deployment remains a separate task: the build guide requires certificates, Kubernetes configuration, deployed custom resources, and Metrics Server for local operator development.

Should you add KEDA to your cluster?

Choose KEDA when an event signal should determine Kubernetes capacity and you can test that signal with the intended workload. KEDA supports event-driven Kubernetes autoscaling, including scaling to and from zero. Its custom resources define scaling rules, and its integration with the Horizontal Pod Autoscaler makes HPA a complement to KEDA.

Our sandbox results support a narrower conclusion than deployment readiness: the recorded install and build steps succeeded, while the test command failed. Before adopting it, validate one workload against its actual event source, including activation from zero and behavior when the source cannot supply a metric.

What our October 1 run established

Our run was recorded on October 1, 2026, at commit 81c6b83, whose full hash is 81c6b8316c2f3ca56f6b554bb45d14dc2c1475cf. This review uses that stored run; no new execution was performed.

Our sandbox build step exited 0 after 466 seconds. Installation exited 0 after 105 seconds. The test command exited 1 after 544 seconds without timing out. The harness stores each step's outcome, exit code, duration, timeout status, and a log excerpt separately from parsed test counts.

The stored parser summaries report 44 passed and 9 failed, totaling 53. These figures do not establish exhaustive unique test coverage. They must not be read as 44 individual tests passing out of 53, or as tests covering all 759 recorded dependency packages. The raw record also lists packages with no test files; those entries are not failed or skipped tests. The skipped-test count is unknown.

The raw failure excerpt names TestAPIs in apis/eventing/v1alpha1, apis/keda/v1alpha1, and controllers/keda. It also contains a panic marker and a failing pkg/scalers entry. Those named failures are evidence from the excerpt, not a replacement aggregate calculated from it. The excerpt does not show enough assertions or surrounding output to assign a cause or reconcile every stored parser outcome.

The sandbox image was golang:1.24-bookworm, with 3 CPUs and 8 GB RAM. Its install tail says it downloaded Go 1.26.0, so describing this simply as a Go 1.24 test would be misleading. The build tail records vet-exit:0; neither that marker nor a successful build establishes that a Kubernetes workload was deployed.

The supplied record does not demonstrate cluster deployment, a live event-source integration, scaling latency, or a successful transition from zero replicas. It contains no audit result, so advisory findings and scan coverage are unknown. The MrKeyoor testing methodology explains the publisher's recording approach and limitations. Its current text does not establish which methodology version governed this older run.

Building locally still leaves cluster setup

The KEDA README lists Helm, Operator Hub, and YAML deployment options. Building from source serves a different purpose from installing a working cluster deployment.

The build guide describes development containers and direct local builds. For running a custom operator outside the cluster, it requires certificates and a Kubernetes configuration, along with deployed CRDs and KEDA components. It also calls for Metrics Server and scaling down the in-cluster operator before running the local operator.

That setup explains why compilation is only an initial check. A useful next step is to deploy one representative workload in staging, confirm that its scaling metric matches the work waiting to be processed, and observe activation from zero. Record what happens when the metric is unavailable as well as when demand rises.

KEDA's testing strategy describes unit checks and end-to-end tests using Kubernetes clusters and cloud resources. Our sandbox command does not reproduce that infrastructure. Its failure warrants investigation, but the supplied excerpt cannot establish whether the cause was project code, the sandbox environment, or another prerequisite.

Which alternatives address your requirement?

HPA is part of KEDA's integration, so treating the two as mutually exclusive would misstate their relationship. Start by identifying the missing capability in your existing scaling setup before adding another component.

Knative Serving supports serverless containers, automatic scaling to zero, routing, and deployment snapshots. Consider it when serving applications or functions is the requirement and those serving primitives matter. The supplied source does not establish that it replaces KEDA for every event-driven workload.

Prometheus Adapter implements Kubernetes Custom, Resource and External Metric APIs for use with HPA. Consider it when the requirement is to expose Prometheus metrics through those APIs. This is an alternative metrics integration path; the supplied extract does not establish equivalent activation behavior to KEDA.

How to read the scores

These are editorial assessments, not measured performance or adoption scores. Setup ease runs from 1 for substantial unresolved prerequisites to 5 for a straightforward demonstrated setup. Documentation runs from 1 for missing essential instructions to 5 for documented deployment, development, and testing paths. Community runs from 1 for no documented participation route to 5 for documented meetings, discussion, contribution, and governance routes. Maturity runs from 1 for little documented operating structure to 5 for established governance and substantial testing infrastructure.

On those criteria, setup ease is 2: the build step succeeded, but local operation needs cluster components and certificates, and the sandbox test command failed. Documentation is 5 for the supplied deployment, build, debugging, and testing instructions. Community is 5 for the README's documented participation and governance routes; that score does not measure response times, adoption, or current activity. Maturity is 5 for documented CNCF graduated status and the testing infrastructure described by the project. It does not certify every scaler or erase the failed sandbox result.

Alternatives

ProjectWhat it isPick it when
Knative ServingA Kubernetes serving layer for serverless containers, with scaling to zero, routing, and deployment snapshots.Consider it when deploying and serving applications or functions is the central requirement. Its documented serving role does not establish a general replacement for KEDA's event-driven scaling.
Prometheus AdapterAn implementation of Kubernetes Custom, Resource and External Metric APIs for use with HPA.Consider it when you need to expose Prometheus metrics through Kubernetes metrics APIs. Verify your required scaling behavior separately rather than assuming parity with KEDA.

What people are saying

  1. [github-trending] kedacore/keda

Sources

  1. KEDA README
  2. KEDA build and deployment guide
  3. KEDA testing strategy
  4. KEDA v2.20.2 release
  5. GitHub Runner pagination pull request
  6. Cosmos DB EPK lease issue

More automation reviews