How we grade

Every grade on ce.rodeo decomposes to arithmetic from inputs you can verify. This page is the formula. Rubric version cerodeo-v1.

The Rodeo grade (per image)

The Rodeo grade is ce.rodeo's own per-image letter grade for "security health of a container image." Docker's own A–F Scout surface was retired from Docker Hub on 2026-07-01, and we never trusted it anyway — we compute the Rodeo grade from the same raw inputs (CVE counts, policy results, supply-chain signals) using the open rubric below, so the number is reproducible from the raw scanner output we also publish.
Previously called the "Scout grade" on this site through 2026-10-27. Renamed to eliminate confusion with Docker's product; the underlying data and column names (scout_snapshots) kept their original names in the schema and API for backward-compat.

The formula

score = 100
      − 25 × critical CVEs with an available fix
      − 10 × high CVEs with an available fix
      −  3 × medium CVEs with an available fix
      −  8 × critical CVEs that have no fix available
      −  3 × high CVEs that have no fix available
      + 10 if image rebuilt within last 90 days
      + 10 if default user is not root
      +  5 if image is cosign-signed
      +  5 if a SLSA provenance attestation is attached
      +  5 if the provenance's subject SHA256 matches the image manifest SHA256
      +  3 if HEALTHCHECK is defined in the image config
      +  3 if the OCI standard labels are populated (title, description, source, version, revision)
      +  3 if the image ships 3+ architectures (+2 for 2 arches)
      +  3 if the image tag matches an upstream GitHub release
      +  3 if the SBOM is attested (not just derivable via syft)
      +  2 if the Docker Hub README has a usable example (docker run or compose snippet)

score = max(0, min(100, score))
grade = A ≥ 85, B ≥ 70, C ≥ 55, D ≥ 40, F < 40

Where every input comes from

InputSource
CVE lists by severity and fixabilityGrype matching our cached syft SBOM against the Grype vuln DB (consults GHSA, NVD, Red Hat, Debian, Ubuntu, Alpine, PyPA, npm advisory DBs)
Non-root default userconfig.User field in the OCI image config
Rebuild freshnessCreated timestamp from the image manifest
cosign signaturesigstore registry lookup via cosign triangulate
SLSA provenance + SHA256 matchcosign download attestation --predicate-type=https://slsa.dev/provenance/v1, DSSE envelope parsing, subject[].digest.sha256 compared to the image manifest digest
HEALTHCHECK, OCI labelsOCI image config blob
Architecture countmanifest list from the registry
Upstream GitHub release matchGET /repos/:owner/:repo/releases/tags/:tag (we have the owner/repo mapping for most tracked projects)
SBOM attestationcosign download attestation --predicate-type=https://spdx.dev/Document
README exampleDocker Hub /v2/repositories/:ns/:repo full_description, regex for docker run or compose block

Scan cadence

Every image is re-matched against the latest Grype DB hourly. We poll Anchore's DB listing on the same hourly tick and promote the new version as soon as it lands; in practice Anchore publishes roughly once a day (sometimes less), so worst-case latency from CVE publication to appearance on ce.rodeo is bounded by their cadence, typically ~1 day. Daily, we HEAD each image's manifest and re-pull if the digest changed. Weekly, we do a sanity sweep that re-pulls every image from scratch.

What this is not

The Pulse grade (per project)

Pulse answers "will this still be alive in 12 months?" independently from the security grade's "is it secure right now?". Five signals, percentile-ranked across the scored set, equal-weighted. Every project page carries a Pulse breakdown card with per-signal percentile bars so the letter isn't an unexplained grade.

  1. Security average — mean of the Rodeo grades across this project's scored variants
  2. Rebuild recency — share of this project's images rebuilt in the last 90 days
  3. GitHub 90-day commit volume (from /stats/participation)
  4. GitHub stars, log-dampened to tame long-tail outliers
  5. HN story count last 90 days via the free Algolia search API

Archived GitHub repos cap at D regardless. Mature stable projects (apache-httpd, memcached) currently underscore because the v0 formula over-rewards attention — a known limitation. Reddit mindshare (per-subreddit story volume) lands next; release cadence, CVE-fix latency, and long-term committer count are on the roadmap.

The Trending ranking

/trending answers "what's moving right now." Two scores are combined. Both show the pulls aggregated across every variant we track for the project (architectures, tag families, publisher clones — all roll up to one project number).

Short-term (7-day heat)

rank_short = 10 × upvotes_7d
           + 15 × comments_7d
           +  8 × grade_upgrades_7d
           +  2 × hn_stories_90d
           +  1 × reddit_posts_30d
           + pulse_bonus  (A=20, B=12, C=6, D=2)
           + security_bonus (A=15, B=8, C=3)

Long-term (6-month trend)

rank_long = min(growth_rate_180d_pct, 500)
          +  2 × ln(pulls_total)
          + pulse_bonus
          + security_bonus

Why cap growth at 500%. A small project going from 10k to 1M pulls is a big story, but we don't want a 50,000% outlier owning the leaderboard forever. The + 2·ln(pulls) term keeps absolute volume visible so a 20% gain on a billion-pull project still beats a 500% gain on a thousand-pull project.

What's missing right now. Pull history is written daily into project_pull_snapshots starting 2026-10-19 — the 30-day column won't be real until mid-November, the 180-day until mid-April. Until the window fills, rank_short carries the page and the delta columns read "collecting." Reddit mindshare lands when the scanner for it ships (ETA this week).

The Publishers ranking (per publisher)

The Rodeo grade scores a single image. Publishers ranks a namespace — bitnami, library (Docker Official), cgr.dev/chainguard, grafana, linuxserver, etc. — by whether they consistently ship high-grade products that have been recently pushed, not by raw volume and not by old abandoned tags lingering in the registry.

The formula (v2, from 2026-10-19)

1. Scope the publisher's images to a 60-day push window.
2. Dedupe to products: one (publisher × project) row,
   grade = best 48h-grace scoring_grade across variants.
3. Count products by grade.

per_product_quality = (3·A + B − 0.5·F) ÷ products_60d
breadth_bonus       = ln(1 + products_60d)
rank_score          = per_product_quality × breadth_bonus

Why 60 days. A publisher who ships a clean A image once and lets it rot shouldn't out-rank one who keeps shipping. We only count products with at least one image pushed in the last 60 days. Products with no activity in the window don't contribute (positive or negative) to the rank.

Why product-level, not image-level. One grade per (publisher, project). If a publisher has five variants of nginx — :1.30, :1.31, :latest, an arm64 build, an alpine build — they count as one product carrying the best grade of the five. This stops a publisher being punished for shipping multiple tags of a well-maintained project.

Why a 48-hour CVE grace in scoring. When a new CVE lands in NVD/GHSA, every image already built against that package drops a grade overnight — but the publisher had no chance to respond. For scoring purposes, each image uses the better of its current scan and its last scan ≥ 48 hours ago. The visible grade shown on image rows is different (see below); only the rank formula is grace-adjusted.

Why log-damped breadth. A publisher with 20 well-maintained products should beat one with 5, but not 4×. ln(1 + N) rises from 0.69 at 1 product to 2.40 at 10, to 3.04 at 20, to 3.93 at 50. Doubling your breadth adds ~0.6 to the multiplier, which is meaningful but not catastrophic; per-product quality still carries the day.

Image-level: visible grade and the 14-day peak

Image rows on project and publisher pages show the best grade seen in the trailing 14 days as the primary chip when the latest scan has regressed. The latest grade + CVE counts appear underneath as a staleness annotation (e.g. "latest C · 10/16 · 3/1/3 C/H/M"). After 14 days without a better scan, the display reverts to the latest grade with no annotation. A brand-new image (fewer than 2 scans in the window) shows its one grade as before. This surfaces regressions honestly while not denying the image was good when it was pushed.

Reproduce any score yourself

We don't use judgement to score — every signal above is deterministic from the image, its manifest, and a pinned CVE DB. For ultimate transparency, every score we publish is tied to a specific rubric version (cerodeo-v1, cerodeo-v2, …) and the Grype DB vintage it was matched against. Both are recorded on every scan snapshot and shown on the image detail page.

To verify a score, run:

curl -fsSLO https://ce.rodeo/verify-score.sh && chmod +x verify-score.sh
./verify-score.sh <image_ref> --rubric cerodeo-v1 --grype-db <version>

Prerequisites on your host: skopeo, syft, grype, cosign, jq, curl. The script fetches the rubric spec at ce.rodeo/data/rubric/<version>.json, pulls the same tools in the same order, applies the same weights, and prints a per-signal breakdown that should match our recorded breakdown bit-for-bit when the Grype DB is pinned.

Diff against our recorded breakdown by passing the --expected flag with the JSON we publish per image at /v1/images/<uuid>/cves. A non-zero exit means the two don't match; the common cause is a drifted Grype DB (vulnerabilities get added, re-rated, or withdrawn after our scan), which the pin flag eliminates.

Source: scripts/verify-score.sh in the (currently private) ce.rodeo repo. Rubric specs: cerodeo-v1.json.

Changelog

The dated changelog lives at /about/methodology — it carries every ranking + rubric change with the switch date, dual-run window, and effect on the top 10 publishers. Below is the summary.

cerodeo-v1
Initial rubric. Published alongside the first scored snapshot in October 2026.
2026-10-21
Governance pass. Four measurement bugs fixed (HEALTHCHECK reaches via raw config, BuildKit in-index attestations credited, cosign verified not presence-credited, upstream-release suffix compare). Freshness dated from first-sighting on ce.rodeo (not config.Created). Severity normalized by CVSS v3 base score. See the methodology changelog.
2026-11-04 (upcoming)
Publisher rank v3 switches on. Newest release per product wins (no best-of-window hiding); ordering key is Wilson-adjusted quality; breadth is a separate column. Dual-running against v2 until then.

Think the rubric should weigh something differently? Mail [email protected].