Tools Used in DevSecOps · Start here

The Tool Landscape

This page is the map for every tool this course teaches in depth — twenty-five of them, one dedicated page each. The Certified DevSecOps Professional (CDP) exam is narrow by design: five live challenges, no multiple choice, and a toolchain its blueprint names directly in only a handful of places. This course covers a much wider ecosystem than that on purpose, because the tool you're actually handed on the job is rarely the one an exam bothered to name. Below: a grouped-by-job view — the way you should actually learn these tools — and then the same twenty-five listed alphabetically, the order the sidebar uses.

☺ Explain it like I'm 10

A hospital doesn't send one doctor to see every patient. A radiologist reads the X-ray, a cardiologist reads the heart monitor, a lab tech reads the blood panel — each one is trained to notice one specific kind of problem, using one specific kind of instrument, and none of them is expected to catch what the others are for. DevSecOps tooling works the same way: a SAST tool reading your source code was never going to notice a leaked AWS key, and a secrets scanner was never going to notice a SQL injection three functions deep. Learn which instrument reads which signal, and a page full of unfamiliar tool names turns into a short list of specialists you already know how to call.

🐿️Your host for this topic: Nutty the Squirrel — twenty-five tools is exactly the kind of archive Nutty keeps: filed by the job each one does, not by which vendor's logo is on the box.

Every tool, in detail

☺ Like you're 10: This page is the map of the whole toolbox. Each tool below also has its own full page — what it's for, how it works, the exact commands, and what usually goes wrong.

Below is the landscape view: why only a handful of these tools are curriculum-named, a job-by-job grouping, and the full A–Z. But each tool also has a dedicated page — what it does, the commands and config you actually write, day-to-day gotchas, and how it compares to its closest rival. All 25 are listed twice on this page: first grouped by the job they do, which is how you should learn them, and then A–Z, which is how the sidebar lists them. If you want the shorter, eight-category conceptual pass first — the question each category answers, without the full tool catalogue — the tooling landscape is that page; this one is the deeper, fuller map it was always pointing to.

★ ◆ The legend — and where it lives

★ marks a tool the CDP curriculum names directly. ◆ marks a wider-ecosystem tool this course covers beyond it. That distinction changes how deep to go: a ★ tool can be handed to you by name in a live challenge, so its exact commands and output format are worth having cold. A ◆ tool is something you should recognize and understand the job of — real pipelines run these constantly — without expecting the exam itself to grade your memory of its flags.

The sidebar does not carry that signal — this page is where it lives. The nav lists the same 25 tools alphabetically, numbered 0125, with no stars: alphabetical order is best for finding a tool you already have a name for, but it deliberately makes no claim about exam relevance. So when you land on a tool page from the sidebar, check it against the A–Z table below before deciding how deep to go.

Worth knowing before you count the stars yourself: only five of the twenty-five carry one — OWASP ZAP, OWASP Dependency-Check, TruffleHog, InSpec, and DefectDojo — because Practical DevSecOps doesn't publish a tool-by-tool syllabus the way a multiple-choice cert does; its blueprint names a small, specific toolchain and leaves the rest of the ecosystem for a candidate, and this course, to cover beyond it. Three of the twenty-five pages also cover two tools each — Syft & Grype, Sigstore & cosign, and OPA & Conftest — because in practice each pair ships and is documented as one workflow, and none of the three is curriculum-named individually either way.

Static analysis (SAST)

Dynamic analysis (DAST)

Software composition analysis (SCA)

Secrets management

Container & supply chain

Infrastructure as code

Policy as code

Runtime security

Compliance as code

Cloud security posture (CSPM)

SIEM & security monitoring

Threat modeling

Vulnerability management & aggregation

A–Z · every tool, with its sidebar number

The same 25 tools in the order the sidebar lists them. Use this when you already know the name and just want the page — or when you've landed on a tool page from the sidebar and want to know, in one glance, whether it's curriculum-named () or wider ecosystem () and which job group it belongs to above.

#Tool★ / ◆Job
01Burp SuiteDynamic analysis — manual and CI-friendly DAST
02CheckovInfrastructure as code — policy-as-code scanning for Terraform / CloudFormation / K8s
03CodeQLStatic analysis — semantic, queryable code analysis
04DefectDojoVulnerability management — aggregation, dedup, SLA triage
05FalcoRuntime security — eBPF syscall-based detection
06gitleaksSecrets management — fast regex / entropy secrets scanning
07HashiCorp VaultSecrets management — dynamic secrets and centralized storage
08InSpecCompliance as code — testable, read-only controls
09KyvernoPolicy as code — Kubernetes-native YAML policy engine
10OPA & ConftestPolicy as code — Rego policy engine plus a CI-friendly CLI
11OpenSCAPCompliance as code — SCAP / XCCDF / OVAL scanning
12OWASP Dependency-CheckSoftware composition analysis — CPE-matched NVD dependency scanning
13OWASP Threat DragonThreat modeling — STRIDE data-flow-diagram editor
14OWASP ZAPDynamic analysis — baseline and active web-app scanning
15ProwlerCloud security posture — multi-cloud CSPM CLI
16ScoutSuiteCloud security posture — multi-cloud audit reporting
17SemgrepStatic analysis — fast pattern-matching SAST
18Sigstore & cosignContainer & supply chain — keyless signing and attestation
19SnykSoftware composition analysis — commercial SCA / container / IaC platform
20SonarQubeStatic analysis — code quality and security gates
21Syft & GrypeContainer & supply chain — SBOM generation and scanning
22tfsecInfrastructure as code — Terraform-focused static analysis
23TrivyContainer & supply chain — all-in-one image / IaC / secret scanner
24TruffleHogSecrets management — live-verified secrets detection
25WazuhSIEM & security monitoring — open-source correlation platform

Count the stars in that table and you get 5 pages carrying a and 20 pages carrying a — a narrower curriculum-named slice than a tool count this size might suggest, and exactly the point: the CDP grades whether you can do the work under pressure, not whether you've memorized twenty-five tools' worth of flags.

⚠ Don't assume the docs are one tab away

The CDP is a live, hands-on exam — five real challenges against a running environment, and every blueprint chapter in this course repeats the same warning: no AI assistant or chatbot is allowed during the window. Whether the vendor's own documentation site is reachable from the exam desktop is exactly the kind of detail that changes between exam updates, so confirm it on the certifications page and the vendor's own current exam guide before you sit it — and build the habit of running a tool from memory and its own --help output regardless of the answer, because that's the skill actually being graded.

Pick a job → see its tools

☺ Like you're 10: Choose a job from the dropdown and you'll see just the tools for that job, with a one-line note and who on the Squad owns it.

Flip the picker below from one DevSecOps job to the next. Each panel lists the relevant tools — curriculum-named and wider-ecosystem alike — with a one-line "what it does" and the character who owns that piece of the pipeline. Every panel links to its full lesson, because this page is the map; the lessons are the territory.

Scanning the Code You Ship — owned by 🐢 Timmy
  • Semgrep: fast pattern-matching SAST — the rule you write today can block a real vulnerability class tomorrow. (◆)
  • SonarQube: a persistent Quality Gate dashboard drawing the line between "clean" and "blocked" release over release. (◆)
  • CodeQL: semantic analysis that treats code as a database, catching data-flow bugs a regex scanner can't see. (◆)
  • OWASP ZAP: passive baseline and active DAST scanning against a live target — the CDP's own named DAST scanner. (★)
  • Burp Suite: manual pentesting plus Dastardly for a free, CI-friendly DAST pass. (◆)
  • Snyk: commercial SCA with IDE- and PR-native dependency findings. (◆)
  • OWASP Dependency-Check: the open-source SCA tool the CDP names directly, matching dependencies by CPE against the NVD. (★)

Full lessons: SAST, DAST & SCA, Static Analysis & Secrets Detection, Software Composition Analysis in Depth, and Dynamic Analysis in Practice.

Secrets Management — owned by 🐘 Ellie
  • gitleaks: fast pre-commit and pipeline scanning by regex and entropy. (◆)
  • TruffleHog: the curriculum-named scanner, live-verifying a credential against the issuing provider instead of guessing. (★)
  • HashiCorp Vault: centralized, dynamic, short-lived secrets — so there's rarely a static credential left to leak in the first place. (◆)

Full lessons: Secrets Management and Static Analysis & Secrets Detection.

Container & Supply Chain — owned by 🦫 Benny & 🐦 Pip
  • Trivy: one binary for image, filesystem, IaC, and secrets scanning, plus SBOM generation. (◆) (🦫 Benny)
  • Syft & Grype: generate the SBOM, then scan it — or scan an image directly. (◆) (🐦 Pip)
  • Sigstore & cosign: keyless signing and a public transparency log, so a signature can be verified without anyone managing a private key. (◆) (🐦 Pip)

Full lessons: Container & Supply-Chain Security and Software Bills of Materials.

Infrastructure as Code & Policy — owned by 🤖 Recon
  • Checkov: hundreds of built-in policies spanning Terraform, CloudFormation, and Kubernetes manifests. (◆)
  • tfsec: static analysis purpose-built for Terraform specifically. (◆)
  • OPA & Conftest: general-purpose Rego, run against any structured config in CI. (◆)
  • Kyverno: Kubernetes-native policy in YAML and CEL, no new language to learn. (◆)

Full lessons: IaC Security & Policy as Code and Infrastructure as Code Hardening.

Runtime & Detection — owned by 🦊 Foxy
  • Falco: eBPF syscall monitoring that alerts the instant a running container does something it was never supposed to. (◆)
  • Wazuh: log analysis, host intrusion detection, and SIEM-style correlation in one deployable stack. (◆)

Full lessons: Incident Response & Forensics, Detection Engineering & Security Observability, and Container Runtime Security.

Compliance & Cloud Posture — owned by 🐿️ Nutty & 🦥 Sol
  • InSpec: compliance-as-code controls, curriculum-named directly. (★) (🐿️ Nutty)
  • OpenSCAP: XCCDF/OVAL scanning against the SCAP Security Guide. (◆) (🐿️ Nutty)
  • Prowler: multi-cloud CSPM CLI checked against the CIS Benchmarks. (◆) (🦥 Sol)
  • ScoutSuite: a multi-cloud audit turned into one browsable HTML report. (◆) (🦥 Sol)

Full lessons: Compliance & Governance, Cloud Security Posture, and Compliance as Code at Scale.

Threat Modeling & Vulnerability Management — owned by 🦝 Rocky & 🐿️ Nutty
  • OWASP Threat Dragon: STRIDE data-flow diagrams, drag-and-drop. (◆) (🦝 Rocky)
  • DefectDojo: aggregation, dedup, and severity/SLA triage across every scanner above — the curriculum's own closing chapter is built around it. (★) (🐿️ Nutty)

Full lessons: Threat Modeling and Vulnerability Management & Triage.

Meeting a tool you've never run — at exam time

☺ Like you're 10: If a tool is new to you, don't panic — read its --help, find one example that already works, and copy the shape of it.

Twenty-five tool pages is a lot to have cold, and a live challenge can still hand you a flag combination or an output format none of them covered in exactly that shape. The transferable skill isn't memorizing every tool's entire surface area — it's making the tool teach you the one command you need, fast, the same way a working DevSecOps engineer meets an unfamiliar CLI on a Tuesday:

🐢 Timmy's drill · 20 min

Pick any small repo with a Dockerfile and a Terraform folder. Run four scans back to back without opening a single tool page first: gitleaks detect --source . --no-git -v, trivy fs ., checkov -d infra/ --compact, and — against a target you're actually authorized to test — zap-baseline.py -t <url> -r report.html -I. For each one, find the flag that switches its output to JSON before you read a single line of the default prose output. That's the entire "unfamiliar tool" drill, in miniature: four tools, four help menus, four JSON flags, and not one tool page opened.

🎬 At the Shift-Left Squad
🐿️

Nutty: Twelve drawers now — SAST, DAST, SCA, secrets, supply chain, IaC, policy, runtime, compliance, cloud posture, SIEM, threat modeling, plus a thirteenth for vulnerability management. Every tool I've filed goes in exactly one drawer... mostly.

🦊

Foxy: Mostly? Trivy alone does supply chain, IaC, and secrets. Which drawer does it go in?

🐿️

Nutty: All three — filed under each one. I catalogue by what a tool actually does, not by what it's called. One binary, three cards in the archive.

🐰

Remy: So I just need to memorize twenty-five names for the flashcards, right? Easy — go.

🐢

Timmy: Memorize the job, not just the name, Remy. The exam only names five of these directly. The other twenty are here because a real pipeline needs them, not because a multiple-choice question would.

🦉

Professor Owl: Which is exactly the point of this page. It's a map, not a syllabus to cram. Learn the jobs, and twenty-five names stop looking like twenty-five things to remember.

◆ Key idea

Twenty-five tools collapse into a dozen jobs, and the CDP curriculum only names five of the twenty-five directly. Neither number is the one to optimize for. Learn the job each category answers — is this code safe, is this dependency known-bad, did a secret leak, is this image trustworthy, is this infrastructure defined safely, is this policy enforced, is something happening right now, can I prove a control holds, is my cloud account configured correctly — and any tool's exact commands become a five-minute --help read instead of a memorization project.

✓ Checkpoint

1. How many of the twenty-five tools on this page does the CDP curriculum name directly, and name two of them. 2. Which three tool pages on this list each cover two tools instead of one, and why are they paired that way? 3. A pipeline already runs Trivy at the build stage. Name two other job categories on this page it could plausibly also cover, and why. 4. What's the first command you should run against a tool you've never used, before opening any doc page?

Check your answers
  1. Five: OWASP ZAP, OWASP Dependency-Check, TruffleHog, InSpec, and DefectDojo — any two of these is a correct answer.
  2. Syft & Grype, Sigstore & cosign, and OPA & Conftest. Each pair ships and is documented as one workflow in practice — Syft builds the SBOM Grype scans, Sigstore's infrastructure is what cosign's CLI drives, and Conftest is simply Rego packaged for CI — so this course treats each pair as one page rather than splitting a single workflow in two.
  3. Supply chain (its native job) plus secrets and IaC — Trivy is a single static binary that scans images, filesystems, IaC definitions, and secrets, and can generate an SBOM, all from one install.
  4. <tool> --help (or -h) — every tool on this page supports it, and it's faster than searching for documentation you may not even be able to reach during a live exam.