Phase 9: Career & Portfolio · 45 min · OWASP GenAI Security Project · MITRE ATLAS · GitHub
The Problem
Ask ten AI security hiring managers whether a candidate needs a certification and you'll get ten different answers, but almost all of them will say the same thing about why certifications matter less here than in traditional security: the field doesn't have a CPA-license equivalent yet. CISSP has existed since 1994 and every security hiring manager knows exactly what it means. CAISP launched in the last few years. AAISM is newer still. None of them have accumulated the decades of hiring-manager trust that CISSP has in traditional AppSec.
That doesn't mean certifications are worthless — it means they play a different role than you might expect. A certification signals that you sat through a curriculum and passed a scenario-based exam at a point in time. It does not signal that you're tracking a threat landscape that changes monthly: a new jailbreak technique goes viral on X, a new CVE against a RAG pipeline gets disclosed, OWASP ships a new revision of the LLM Top 10. The credential that actually moves the needle in this field is the combination of one certification in progress or completed plus visible, ongoing community participation — because the second one is the only proof that your knowledge isn't already six months stale.
A credential and a community footprint answer different questions
A certification answers "did you study a broad curriculum." A merged pull request against the OWASP LLM Top 10 repo, or a MITRE ATLAS technique mapped to your own project, answers "are you tracking what's happening right now." Hiring managers who have been burned by candidates with a badge and no practical fluency have started asking for the second thing explicitly — "what have you contributed to the community" is a real interview question in this field, not a soft-skills afterthought.
The certifications landscape, honestly
Three certifications are worth evaluating right now. Here's what each one actually signals — not the marketing copy on its landing page.
CAISP (Certified AI Security Professional) — issued by Practical DevSecOps. A 6-hour, roughly 600-question scenario-based exam covering LLM/RAG vulnerabilities, AI supply chain risk, and compliance frameworks like ISO/IEC 42001 and the EU AI Act. No formal prerequisite. This is the most technically hands-on of the three, and the scenario format means it's closer to applied knowledge than trivia recall. Its honest limitation: it's a newer credential with a smaller hiring-manager recognition base than CISSP or CISM, so you still need a portfolio artifact behind it (see lesson 09.01) — most hiring managers will ask you to walk through real work regardless of which badge you hold.
AAISM (Advanced in AI Security Management) — issued by ISACA. A 90-question exam across three domains: AI security policy and governance, risk/supply chain management, and security controls. Here's the detail that surprises people: AAISM explicitly requires holding CISM or CISSP first. It is a management-track add-on, not an entry credential. If you don't already hold one of those, this is a multi-year path. What it signals when you do have it: you can operate at the governance layer — advising stakeholders on AI security policy, not just finding vulnerabilities — which carries real weight with compliance-facing hiring managers and auditors.
CISSP + ISC2's AI security track — there is no separate "CISSP with AI concentration" certification. What actually exists: ISC2 has published exam guidance mapping AI security concepts across the existing CISSP domains, and offers a separate "Building AI Strategy" certificate (six on-demand courses, about 16 hours). If you already hold CISSP — which requires five years of paid experience across at least two of its eight domains — stacking the AI Security certificate on top is a fast, credible way to show deliberate, recent investment in the AI-specific extension of a credential a hiring committee already trusts. Describe this accurately on a resume: "CISSP + ISC2 AI Security Certificate," not an invented concentration name.
| Certification | Issuer | Prerequisite | Best for |
|---|
| CAISP | Practical DevSecOps | None | AI Security Engineer, LLM App Security Engineer, AI Security Consultant |
| AAISM | ISACA | CISM or CISSP | AI Governance & Compliance Engineer, AI Security Architect |
| CISSP + AI Security Certificate | ISC2 | 5 years' experience for CISSP | AI Security Architect, Governance & Compliance, Consultant |
A candidate targeting an AI Governance & Compliance Engineer role is deciding between CAISP and AAISM. They do not currently hold CISSP or CISM. What should they do?
AAISM is explicitly gated behind holding CISM or CISSP — it's a management-track add-on, not an entry point. A candidate without either of those prerequisites cannot sit the AAISM exam yet, regardless of how well-matched it is to their target role. CAISP has no such prerequisite and is directly relevant to AI governance work (it covers ISO/IEC 42001 and EU AI Act content), making it the achievable near-term move, with AAISM becoming realistic later once CISSP or CISM is in hand.
Becoming an OWASP LLM top 10 contributor
"Contribute to open source" is useless advice without a concrete first step. The OWASP GenAI Security Project — home of the LLM Top 10 — has a public GitHub repository, an active Slack working group, and bi-weekly sync meetings, and the on-ramp is lower than most candidates assume:
- Join first, contribute second. Go to the contribute guide, join the OWASP Slack, and find the
#project-top10-llm channel. Attend one bi-weekly sync before writing anything — you'll see how the working group actually prioritizes issues, which is different from guessing at it from the outside. - Your first contribution should be small and specific. Opening an issue proposing a real-world example or CVE reference for one of the 10 categories that currently lacks one is a legitimate, achievable first move — it doesn't require you to already be an expert, just to have noticed a gap.
- Your second contribution should draw on your own work. If you built a guardrail pipeline in Phase 5 or a detector in Phase 2, a documented mitigation-pattern PR that references what you actually implemented is far more credible than a generic writeup, and it doubles as a portfolio artifact.
- Track the project's release history, not just its current snapshot. The LLM Top 10 has already been revised multiple times since its first release — if your mental model of "the 10 categories" is from a version that's two revisions old, that's a specific, checkable gap an interviewer can catch.
AI village at DEF CON and the MITRE ATLAS community
AI Village (aivillage.org) runs education, CTFs, and adversarial-testing exercises around AI systems, with a presence at DEF CON in Las Vegas every August. You do not need to fly to Las Vegas to get value from it — the events page publishes remote CTFs and past-year materials, and the Generative Red Team exercises run at DEF CON are close to a live rehearsal of the think-aloud attack discovery interview format from lesson 09.03. If you do attend in person, treat it as both a learning opportunity and a networking one — this is a small enough field that the same names show up across companies, and AI Village is where a lot of them are in one place.
MITRE ATLAS (atlas.mitre.org) is less a "community you join" in the social sense and more a living knowledge base you should be citing by name. Its case studies are drawn from real incidents, not hypotheticals, which makes them one of the fastest ways to see how a theoretical attack technique actually played out against a production system. The single highest-leverage exercise here: take one finding from your own Phase 4 or Phase 6 course project and map it to a specific ATLAS tactic and technique ID. That turns "familiar with MITRE ATLAS" from a resume claim into a specific, checkable artifact — and interviewers explicitly look for named technique IDs as a signal of framework fluency, not just intuition (see lesson 09.03's threat modeling guidance).
A candidate's resume says "familiar with MITRE ATLAS" under skills. During an interview, they're asked to name a specific ATLAS technique relevant to a RAG poisoning scenario and can't. What would have prevented this gap, according to this lesson?
Vague familiarity claims are exactly what live interviews are designed to expose. The fix isn't to avoid claiming the skill or to memorize a list in the abstract — it's to do the concrete exercise this lesson recommends: take a real finding from your own Phase 4 or Phase 6 project and map it to a specific technique ID before the interview. That gives you a rehearsed, specific answer to reach for instead of trying to recall an abstract taxonomy under pressure.
Build
Build it
The cert_community_planner.py script below is a reference generator, not a quiz. It holds a structured knowledge base of the 3 certifications and 4 community channels covered in this lesson — each with real URLs, honest limitations, and leveled contribution ideas — and assembles a personalized study plan checklist (This week / Next 30 days / Next 90 days) based on your target role and current experience level. Run it with no arguments for a demo plan targeting AI Security Engineer at an intermediate level; use --role and --level to generate your own.
"""
lesson_09_04_cert_community_planner.py
A reference generator for the AI security certifications and community
landscape. This is not a quiz or a scorer — it's a structured knowledge base
plus a study-plan builder, because the honest answer to "which certification
should I get" and "how do I get involved" changes depending on your target
role and how much time you have.
Covers:
- The 3 certifications actually worth evaluating right now: CAISP
(Practical DevSecOps), AAISM (ISACA), and CISSP + ISC2's AI security
certificate track — with what each one actually signals, not marketing
copy.
- The 4 community channels that matter: the OWASP GenAI Security Project /
LLM Top 10 GitHub repo, the OWASP Slack working group, MITRE ATLAS, and
AI Village at DEF CON.
- A concrete, leveled contribution ladder for the OWASP LLM Top 10 project,
since "contribute to open source" is useless advice without specifics.
Usage:
python lesson_09_04_cert_community_planner.py # demo: intermediate, AI Security Engineer
python lesson_09_04_cert_community_planner.py --level beginner --role "AI Red Team Engineer"
python lesson_09_04_cert_community_planner.py --list-certs
python lesson_09_04_cert_community_planner.py --list-channels
Requirements:
Standard library only. No API keys, no network calls, runs fast on CPU.
"""
from __future__ import annotations
import argparse
import json
from dataclasses import dataclass, asdict, field
from datetime import date
from pathlib import Path
# ── Certifications ────────────────────────────────────────────────────────────
# Real, currently-active credentials as of this writing. None of these are a
# CPA-license equivalent for AI security yet — that credential doesn't exist.
# Each entry states what the certification actually signals to a hiring
# manager, not what its marketing page claims.
@dataclass
class Certification:
name: str
issuer: str
url: str
format: str
prerequisite: str
what_it_signals: str
honest_limitation: str
best_for_roles: list[str]
CERTIFICATIONS: list[Certification] = [
Certification(
name="CAISP (Certified AI Security Professional)",
issuer="Practical DevSecOps",
url="https://www.practical-devsecops.com/certified-ai-security-professional/",
format="6-hour, ~600-question scenario-based exam; self-paced training available",
prerequisite="None formally required; assumes working familiarity with AI/ML systems",
what_it_signals=(
"You've studied a broad, current curriculum spanning LLM/RAG vulnerabilities, "
"AI supply chain risk, and compliance frameworks (ISO/IEC 42001, EU AI Act). "
"Scenario-based format means it's closer to applied knowledge than trivia."
),
honest_limitation=(
"Newer credential with a smaller hiring-manager recognition base than CISSP or "
"CISM. Pair it with a visible portfolio artifact (see lesson 09.01) rather than "
"relying on the badge alone — most hiring managers in this field will ask you to "
"walk through real work regardless of which certification you hold."
),
best_for_roles=["AI Security Engineer", "LLM Application Security Engineer", "AI Security Consultant"],
),
Certification(
name="AAISM (Advanced in AI Security Management)",
issuer="ISACA",
url="https://www.isaca.org/credentialing/aaism",
format="90-question exam across 3 domains: policy/governance, risk/supply chain, security controls",
prerequisite="Requires holding CISM or CISSP first — this is explicitly a management-track add-on, not an entry credential",
what_it_signals=(
"You can operate at the management/governance layer: advising stakeholders on AI "
"security policy, data governance, and incident response, not just finding "
"vulnerabilities. ISACA's brand carries real weight with compliance-facing hiring "
"managers and auditors."
),
honest_limitation=(
"The CISM/CISSP prerequisite makes this a multi-year path if you don't already hold "
"one. It signals governance and risk management competence, not red teaming or "
"hands-on technical skill — don't lead with this for an AI Red Team Engineer role."
),
best_for_roles=["AI Governance & Compliance Engineer", "AI Security Architect"],
),
Certification(
name="CISSP + ISC2 AI Security integration",
issuer="ISC2",
url="https://www.isc2.org/landing/ai-security-skills",
format=(
"CISSP is the base 8-domain exam. ISC2 has integrated AI security concepts across "
"its exam guidance and offers a separate 'Building AI Strategy' certificate "
"(6 on-demand courses, ~16 hours)"
),
prerequisite="CISSP requires 5 years of cumulative paid work experience in 2+ of its 8 domains",
what_it_signals=(
"CISSP alone signals broad, established security management competence — it is "
"the most widely recognized security credential a non-technical hiring committee "
"will already know. Stacking the AI Security certificate on top shows deliberate, "
"recent investment in the AI-specific extension of that base."
),
honest_limitation=(
"There is no separate 'CISSP with AI concentration' credential — ISC2 has woven AI "
"content into the existing CISSP domains rather than issuing a distinct badge. "
"Describe this accurately on a resume: 'CISSP + ISC2 AI Security Certificate,' not "
"an invented concentration name."
),
best_for_roles=["AI Security Architect", "AI Governance & Compliance Engineer", "AI Security Consultant"],
),
]
# ── Community channels ────────────────────────────────────────────────────────
@dataclass
class CommunityChannel:
name: str
url: str
kind: str
time_commitment: str
contribution_ideas: list[str]
COMMUNITY_CHANNELS: list[CommunityChannel] = [
CommunityChannel(
name="OWASP GenAI Security Project / LLM Top 10 (GitHub)",
url="https://github.com/OWASP/www-project-top-10-for-large-language-model-applications/",
kind="Open source project — the closest thing this field has to a living standard",
time_commitment="1-3 hours/week if actively contributing; 15 min/week to just watch releases",
contribution_ideas=[
"First timer: open an issue proposing a real-world example or CVE reference for one of the 10 categories that currently lacks one",
"Intermediate: submit a PR adding a mitigation pattern you actually implemented (e.g. your Phase 5 guardrail pipeline) as a documented example",
"Advanced: join the bi-weekly working group sync and take an open issue labeled 'help wanted' end-to-end",
],
),
CommunityChannel(
name="OWASP GenAI Security Project (main site + contribute guide)",
url="https://genai.owasp.org/contribute/",
kind="Project hub — Slack signup, meeting schedule, working group list",
time_commitment="15 min to join; ongoing if you join a working group",
contribution_ideas=[
"Join the OWASP Slack and the #project-top10-llm channel",
"Attend one bi-weekly sync meeting before contributing code, to see how the working group actually operates",
"Watch the project's GitHub releases so your threat model vocabulary stays aligned with the current version, not the one you first learned",
],
),
CommunityChannel(
name="MITRE ATLAS",
url="https://atlas.mitre.org/",
kind="Adversarial ML threat knowledge base and case-study library",
time_commitment="30 min/month to review new case studies as they're published",
contribution_ideas=[
"Map one of your own Phase 4 or Phase 6 course project findings to a specific ATLAS tactic and technique ID — this is a concrete, checkable exercise, not vague familiarity",
"Read one new case study per month; ATLAS case studies are drawn from real incidents and are the fastest way to see how theoretical attacks actually played out",
"Reference ATLAS technique IDs by name in your portfolio threat models (lesson 09.01) — interviewers explicitly look for this",
],
),
CommunityChannel(
name="AI Village (DEF CON)",
url="https://aivillage.org/",
kind="Community running education, CTFs, and adversarial-testing exercises around AI systems",
time_commitment="Ongoing online presence; DEF CON itself is one week/year in Las Vegas",
contribution_ideas=[
"You do not need to attend DEF CON in person to participate — check the events page for remote CTFs and published materials from past years",
"If you do attend, the Generative Red Team exercises are a direct, hands-on rehearsal of the live red teaming interview format from lesson 09.03",
"Follow the AI Village write-ups from past events as a source of real attack techniques that predate their appearance in academic papers",
],
),
]
# ── Study plan generation ─────────────────────────────────────────────────────
ROLE_TO_CERT_PRIORITY: dict[str, str] = {
"AI Security Engineer": "CAISP (Certified AI Security Professional)",
"AI Red Team Engineer": "CAISP (Certified AI Security Professional)",
"DevSecOps for AI Pipelines": "CAISP (Certified AI Security Professional)",
"AI Security Architect": "CISSP + ISC2 AI Security integration",
"AI Governance & Compliance Engineer": "AAISM (Advanced in AI Security Management)",
"LLM Application Security Engineer": "CAISP (Certified AI Security Professional)",
"Adversarial ML Researcher/Engineer": "CAISP (Certified AI Security Professional)",
"AI Security Consultant": "CISSP + ISC2 AI Security integration",
}
LEVEL_INDEX = {"beginner": 0, "intermediate": 1, "advanced": 2}
@dataclass
class StudyPlanItem:
horizon: str # "This week" | "Next 30 days" | "Next 90 days"
action: str
why: str
@dataclass
class StudyPlan:
role: str
level: str
recommended_cert: str
generated: str
items: list[StudyPlanItem] = field(default_factory=list)
def to_dict(self) -> dict:
return asdict(self)
def build_study_plan(role: str, level: str) -> StudyPlan:
cert_name = ROLE_TO_CERT_PRIORITY.get(role, "CAISP (Certified AI Security Professional)")
cert = next(c for c in CERTIFICATIONS if c.name == cert_name)
idx = LEVEL_INDEX.get(level, 1)
owasp_repo = COMMUNITY_CHANNELS[0]
owasp_hub = COMMUNITY_CHANNELS[1]
atlas = COMMUNITY_CHANNELS[2]
items = [
StudyPlanItem(
horizon="This week",
action=f"Join the OWASP Slack via {owasp_hub.url} and the #project-top10-llm channel",
why="Lowest-effort, highest-signal way to see what the field is actively arguing about right now, before you commit study time to any one certification.",
),
StudyPlanItem(
horizon="This week",
action=owasp_repo.contribution_ideas[idx],
why="A leveled first contribution to the OWASP LLM Top 10 repo — matched to your stated experience level so it's achievable, not aspirational.",
),
StudyPlanItem(
horizon="Next 30 days",
action=f"Map one finding from your own Phase 4 or Phase 6 project to a specific technique ID at {atlas.url}",
why="Turns 'familiar with MITRE ATLAS' from a resume claim into a specific, checkable artifact you can point to in an interview.",
),
StudyPlanItem(
horizon="Next 30 days",
action=f"Read the exam content outline for {cert.name} at {cert.url} and decide whether the prerequisite path fits your timeline",
why=f"Matched to your target role ({role}): {cert.what_it_signals}",
),
StudyPlanItem(
horizon="Next 90 days",
action=f"Either sit the {cert.name} exam, or — if the prerequisite path is multi-year — start it while leading with portfolio artifacts in the meantime",
why=cert.honest_limitation,
),
StudyPlanItem(
horizon="Next 90 days",
action="Attend one OWASP GenAI Security Project bi-weekly sync meeting and one AI Village online event or CTF",
why="A credential in progress plus visible community participation reads as materially more current than a credential alone — this is the combination hiring managers say they actually notice.",
),
]
return StudyPlan(
role=role,
level=level,
recommended_cert=cert.name,
generated=date.today().isoformat(),
items=items,
)
# ── Rendering ──────────────────────────────────────────────────────────────────
def render_markdown(plan: StudyPlan) -> str:
lines = [
"# Certifications & Community Study Plan",
"",
f"_Generated {plan.generated} for target role: **{plan.role}** (level: {plan.level})_",
"",
f"**Recommended certification to prioritize:** {plan.recommended_cert}",
"",
"## Checklist",
"",
]
for horizon in ["This week", "Next 30 days", "Next 90 days"]:
lines.append(f"### {horizon}")
lines.append("")
for item in plan.items:
if item.horizon != horizon:
continue
lines.append(f"- [ ] {item.action}")
lines.append(f" - _Why:_ {item.why}")
lines.append("")
lines.append("## Certifications reference")
lines.append("")
for cert in CERTIFICATIONS:
lines.append(f"### {cert.name} — {cert.issuer}")
lines.append(f"{cert.url}")
lines.append("")
lines.append(f"- **Format:** {cert.format}")
lines.append(f"- **Prerequisite:** {cert.prerequisite}")
lines.append(f"- **What it signals:** {cert.what_it_signals}")
lines.append(f"- **Honest limitation:** {cert.honest_limitation}")
lines.append(f"- **Best for:** {', '.join(cert.best_for_roles)}")
lines.append("")
lines.append("## Community channels reference")
lines.append("")
for ch in COMMUNITY_CHANNELS:
lines.append(f"### {ch.name}")
lines.append(f"{ch.url}")
lines.append(f"- **What it is:** {ch.kind}")
lines.append(f"- **Time commitment:** {ch.time_commitment}")
for idea in ch.contribution_ideas:
lines.append(f" - {idea}")
lines.append("")
return "\n".join(lines)
# ── CLI ────────────────────────────────────────────────────────────────────────
def main() -> None:
parser = argparse.ArgumentParser(description="Build a certifications + community study plan.")
parser.add_argument("--role", type=str, default="AI Security Engineer",
choices=list(ROLE_TO_CERT_PRIORITY.keys()),
help="Target job role from the course's 8 covered roles.")
parser.add_argument("--level", type=str, default="intermediate",
choices=list(LEVEL_INDEX.keys()),
help="Your current experience level, used to pick an achievable first contribution.")
parser.add_argument("--out", type=str, default="STUDY_PLAN.md", help="Output markdown file.")
parser.add_argument("--list-certs", action="store_true", help="Print the certification reference and exit.")
parser.add_argument("--list-channels", action="store_true", help="Print the community channel reference and exit.")
args = parser.parse_args()
if args.list_certs:
for cert in CERTIFICATIONS:
print(f"{cert.name} ({cert.issuer}) — {cert.url}")
return
if args.list_channels:
for ch in COMMUNITY_CHANNELS:
print(f"{ch.name} — {ch.url}")
return
plan = build_study_plan(args.role, args.level)
markdown = render_markdown(plan)
out_path = Path(args.out)
out_path.write_text(markdown, encoding="utf-8")
json_path = out_path.with_suffix(".json")
json_path.write_text(json.dumps(plan.to_dict(), indent=2), encoding="utf-8")
print(f"Built a study plan for '{args.role}' (level: {args.level}).")
print(f"Recommended certification: {plan.recommended_cert}")
print(f"Wrote {out_path} and {json_path}.")
print(f"{len(plan.items)} checklist items across This week / Next 30 days / Next 90 days.")
if __name__ == "__main__":
main()