Running AWS SATv2 Security Assessments with Kiro Skills
Add a skill, answer a few questions, and let Kiro deploy, monitor, and review your SATv2 security assessment - single account or across your entire org.
AWS provides the Self-Service Security Assessment Solution (SATv2) — an open-source tool that deploys Prowler via CloudFormation and CodeBuild to generate point-in-time security reports.
SATv2 is designed to be straightforward — a single CloudFormation template that deploys, runs the scan, and delivers results. But what if you could make the experience even more conversational? Ask Kiro to run an assessment, answer a few questions, and let it handle the rest — including detecting existing deployments, comparing template versions against GitHub, downloading results, and recommending cleanup when you're done.
That's what the SATv2 Assessment skill does. It's a Kiro skill — a portable instruction set that wraps the SATv2 deployment workflow in a guided, interactive experience. The full skill file is included at the end of this article.
What You'll Need
- Kiro IDE installed
- AWS CLI v2 configured (SSO recommended — the skill guides setup if needed)
- AWS account with permissions to deploy CloudFormation stacks and create IAM roles
Step 1: Add the Skill
In your Kiro IDE project:
- Create a folder:
.kiro/skills/satv2-assessment/
- Create a file inside it:
SKILL.md
- Copy the full skill content from the Appendix: SKILL.md at the end of this article
That's it — the skill is ready to use. It's just structured instructions that Kiro follows.
Step 2: Start the Skill
Type
/satv2-assessment in the Kiro chat. Kiro asks five questions, one at a time:Question | What It Means |
|---|---|
Single or multi-account? | Determines the entire deployment flow |
AWS profile(s)? | Lists profiles, guides SSO setup if needed, validates sessions |
Scan type? | Basic (13 checks), Intermediate (critical+high), Full (500+ checks) |
Email address? | Mandatory — you'll come back after the notification |
Reporting? (multi only) | Consolidated CSV + SHIP HealthCheck presentation |
Here's what a single-account setup looks like:
You: /satv2-assessment
Kiro: Are we running SATv2 for a single account or multiple accounts in your AWS Organization?
You: Single account
Kiro: I found these CLI profiles: - default - dev-account - audit-prod - mgmt-prod Which profile should run the assessment?
You: dev-account
Kiro: ✓ Profile validated: account 123456789012 (us-west-2) Checking for existing SATv2 deployments... No existing sat2 stacks found.
What level of scan? - Basic (13 checks) — recommended for first-time - Intermediate (critical + high) - Full (500+ checks)
You: Basic
Kiro: What email address should I send the scan completion notification to?
You: myemail@example.com
Kiro: Deploying SATv2... ✓ Stack sat2 created successfully ✓ CodeBuild project started
The scan is running. You'll get an email at myemail@example.com when it completes. Come back to me then and we'll review the results together.
Five questions, one deployment. Kiro handles the CloudFormation parameters, IAM capabilities, and CodeBuild trigger automatically.
Step 3: What Happens Behind the Scenes
After you answer the questions, Kiro:
- Downloads the latest SATv2 CloudFormation template from GitHub
- Deploys it with the right parameters based on your choices
- A Lambda function auto-triggers the CodeBuild project
- CodeBuild runs the assessment
- Results are uploaded to an S3 bucket
- You get an email notification
For multi-account scans, Kiro also handles the prerequisites automatically — looking up the root OU ID, deploying member roles via StackSets, polling until the StackSet completes, and verifying Organizations access before deploying the main stack.
Step 4: Existing Deployment Detection
If you've run SATv2 before, Kiro detects it. When it finds an existing
sat2* stack, it does two things automatically:- Compares the deployed template against the latest version on GitHub — so you know if you're running an outdated version
- Checks the CodeBuild scan status — succeeded, in progress, failed, or never triggered
Then it presents only the options that make sense:
Kiro: I found an existing SATv2 deployment: sat2 (created 2026-03-15) Template: outdated — a newer version is available on GitHub Last scan: SUCCEEDED (2026-03-15)
What would you like to do? 1. Review results — open the HTML report for the last scan 2. Upgrade & scan — deploy latest version and run a fresh scan 3. Start fresh — delete everything and set up from scratch
You: 1
No guessing about what state things are in — Kiro checks and tells you.
Step 5: Multi-Account — The Guided Experience
Multi-account is where the skill really shines. Without it, you'd need to read through the SATv2 README, figure out StackSets, look up your root OU ID, set up Organizations access, and coordinate deployments across two accounts. With the skill, it's the same five questions — Kiro handles the rest.
You: /satv2-assessment
Kiro: Are we running SATv2 for a single account or multiple accounts?
You: Multiple accounts
Kiro: I found these CLI profiles: - mgmt-prod - audit-prod - dev-account Which profile is for the AWS management account?
You: mgmt-prod
Kiro: ✓ Management account: 111111111111
Which profile is for the audit/security tooling account that will run the assessment?
You: audit-prod
Kiro: ✓ Audit account: 222222222222 Checking for existing deployments... No existing sat2 stacks found.
What level of scan? (Basic / Intermediate / Full)
You: Intermediate
Kiro: What email address for the completion notification?
You: myemail@example.com
Kiro: Reporting consolidates all account results into a single CSV and generates a SHIP HealthCheck presentation. Turn it on?
You: Yes
Kiro: Starting multi-account deployment...
Step A — Deploying member roles via StackSet ✓ Root OU: r-abcd ✓ StackSet sat2-member-roles created ✓ Stack instances deploying to all OUs... Polling: IN_PROGRESS... Polling: IN_PROGRESS... ✓ StackSet deployment SUCCEEDED
Step B — Verifying Organizations access ✓ Resource policy found — audit account has ListAccounts access
Step C — Deploying SATv2 from audit account ✓ Stack sat2-prowler created ✓ CodeBuild project started
The multi-account scan is running. You'll get an email at myemail@example.com when it completes (and a second email when the consolidated report is ready). Come back to me then and we'll review together.
Notice what Kiro did automatically without asking:
- Looked up the root OU ID (
r-abcd)
- Polled the StackSet operation until it completed
- Checked Organizations access (found an existing resource policy)
- Only then deployed the main SATv2 stack
If Organizations access hadn't existed, Kiro would have offered to create a resource policy — showing the exact command and waiting for confirmation.
Step 6: Reviewing Results
When you come back after the email notification, Kiro starts the result review immediately:
You: My SATv2 scan completed
Kiro: Pulling up your results... ✓ Found bucket: sat2-prowler-prowlerfindingsbucket-abc123 ✓ Downloaded results to sat2-results/ ✓ Opening HTML report...
SATv2 includes a static HTML report in the reporting folder that loads the consolidated CSV — use it to filter and explore findings by severity, account, service, or region. No additional tools to install.
SATv2 generates a static HTML report that loads the consolidated CSV file, giving you an interactive view of all findings right in your browser — no local tooling required. For multi-account scans with Reporting enabled, you'll also find a consolidated CSV and SHIP HealthCheck presentation in the
/reports folder.Step 7: Clean Up
After you're done reviewing, Kiro proactively recommends cleanup:
Kiro: You've got your results downloaded locally and the S3 bucket with reports will be retained. Want me to clean up the SATv2 stack now? It's designed to be temporary — you can always re-deploy for a fresh scan later.
You: Yes
Kiro: ✓ Deleted stack sat2-prowler ✓ Deleted StackSet instances ✓ Deleted StackSet sat2-member-roles
Cleaned up. Your scan results are still in the S3 bucket and downloaded locally in sat2-results/.
SATv2 is a point-in-time assessment tool — once the CodeBuild scan completes, there's nothing actively running. Cleaning up removes the CloudFormation resources so they don't sit idle in your account. Your results are safe in S3 and on your local machine.
Key Takeaways
- Add the skill, start assessing — no scripts to install, no infrastructure to pre-configure. The skill is a single
SKILL.mdthat teaches Kiro the entire SATv2 assessment workflow.
- The skill adapts to your environment — single account or multi-account, Basic or Full scan, existing deployment or fresh start. Kiro asks, you answer, it builds the workflow around you.
- Auto-detection over manual input — Kiro discovers existing deployments, compares template versions against GitHub, looks up root OU IDs, verifies Organizations access, and polls StackSet operations. You don't have to know the plumbing.
- Assess first, remediate second — this skill runs the assessment. The Security Hub Remediation Kiro Skill picks up where it leaves off to fix what you found.
- Point-in-time by design — SATv2 is temporary. Kiro deploys it, runs the scan, shows you results, and recommends cleanup. For continuous monitoring, enable AWS Security Hub .
SATv2 assessments don't have to mean reading through READMEs and figuring out CloudFormation parameters. Add the skill, answer a few questions, and start assessing.
This skill is a starting point — customize the scan types, reporting options, or review workflow for your team.
Appendix: SKILL.md
Create this file at
.kiro/skills/satv2-assessment/SKILL.md in your project:---name: satv2-assessmentdescription: Deploy and run AWS SATv2 (Self-Service Security Assessment Solution) using Prowler-based security scanning via CloudFormation. Guides users through account selection, scan configuration, deployment, monitoring, result retrieval, and finding review using SATv2's built-in HTML report.---
## Setup Flow
Ask questions one at a time. Wait for each answer before proceeding.
### Step 1 — Single or Multi-Account?
> **Are we running SATv2 for a single account or multiple accounts in your AWS Organization?**
- **Single account** — scans one account. One CloudFormation stack.- **Multi-account** — scans all accounts from a central audit account. Requires StackSets + IAM roles in member accounts.
Do NOT proceed until the user explicitly chooses.
### Step 2 — AWS Profiles
List available profiles:```bashaws configure list-profiles```
If no profiles exist or the user needs a new one, guide through SSO setup:```bashaws configure sso```Walk through: SSO session name → start URL → SSO region → accept default scopes → browser auth → select account + role → default region (`us-west-2`) → output (`json`) → profile name (suggest `mgmt-prod`, `audit-prod`).
**Single account** — ask for one profile.**Multi-account** — ask for two: management account profile, then audit/Prowler account profile.
For each selected profile, validate the session:```bashaws sts get-caller-identity --profile <profile>```If expired, guide re-auth: `aws sso login --profile <profile>`, then retry.
Confirm the account ID with the user before proceeding.
Confirm region (default: `us-west-2`).
### Step 3 — Check for Existing Deployment
After profiles are validated, check if SATv2 is already deployed:
```bashaws cloudformation describe-stacks --profile <profile> --region <region> \ --query "Stacks[?starts_with(StackName,'sat2')].{Name:StackName,Status:StackStatus,Created:CreationTime}" \ --output table```
**If no stack found**, continue to Step 4.
**If a stack is found**, do two things:
#### 3a. Check template version
Compare the deployed template against the latest from GitHub:
```bash# Get deployed templateaws cloudformation get-template --stack-name <stack-name> \ --profile <profile> --region <region> \ --query "TemplateBody" --output text > /tmp/sat2-deployed.yaml
# Get latest template from GitHubcurl -sL https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/2-sat2-codebuild-prowler.yaml > /tmp/sat2-latest.yaml
# Comparediff /tmp/sat2-deployed.yaml /tmp/sat2-latest.yaml```
#### 3b. Check CodeBuild scan status
```bashPROJECT=$(aws cloudformation describe-stack-resources --stack-name <stack-name> \ --query "StackResources[?ResourceType=='AWS::CodeBuild::Project'].PhysicalResourceId" \ --output text --profile <profile> --region <region>)
BUILD_ID=$(aws codebuild list-builds-for-project --project-name $PROJECT \ --query "ids[0]" --output text --profile <profile> --region <region>)
aws codebuild batch-get-builds --ids $BUILD_ID \ --query "builds[0].{Status:buildStatus,Phase:currentPhase,Start:startTime,End:endTime}" \ --profile <profile> --region <region>```
#### 3c. Present options to the user
Summarize what was found and offer clear choices:
> **I found an existing SATv2 deployment: `<stack-name>` (created `<date>`).**> **Template: `<up to date>` or `<outdated — a newer version is available on GitHub>`**> **Last scan: `<status>` (`<date>`)**>> **What would you like to do?**> 1. **Review results** — open the HTML report for the last completed scan *(only if SUCCEEDED)*> 2. **Re-run scan** — trigger a new scan using the existing deployment *(only if SUCCEEDED or FAILED)*> 3. **Upgrade & scan** — delete the old stack, deploy the latest version, and run a fresh scan *(if template is outdated)*> 4. **Start fresh** — delete everything and set up from scratch> 5. **Wait** — the scan is still running, come back after the email *(only if IN_PROGRESS)*
Only show options that apply based on the template version and build status. For example:- Template outdated + build SUCCEEDED → show options 1, 3, 4- Template current + build SUCCEEDED → show options 1, 2, 4- Template outdated + build FAILED → show options 3, 4- Template current + build IN_PROGRESS → show option 5 only- Stack exists but no builds → show options 2, 3, 4
**If no stack found**, continue to Step 4.
### Step 4 — Scan Type
> **What level of scan?**
| Type | Checks | Best For ||------|--------|----------|| **Basic** (default) | 13 | First-time assessment || **Intermediate** | Critical + High | Follow-up || **Full** | 500+ | Comprehensive audit |
Recommend Basic for first-time, Intermediate for follow-ups.
### Step 5 — Email & Reporting
**Email is mandatory** — the user comes back after the notification to review results.
> **What email address should I send the scan completion notification to?**
Do NOT proceed without an email.
For **multi-account**, also recommend Reporting (default yes):> **Reporting consolidates all results into a single CSV and SHIP HealthCheck presentation. Turn it on?**
## Deploy — Single Account
```bashwget https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/2-sat2-codebuild-prowler.yaml
aws cloudformation deploy \ --template-file 2-sat2-codebuild-prowler.yaml \ --stack-name sat2 \ --capabilities CAPABILITY_NAMED_IAM \ --parameter-overrides ProwlerScanType=<type> EmailAddress=<email> \ --profile <profile> --region <region>```
After deployment:> **The scan is running. You'll get an email at `<email>` when it completes. Come back to me then and we'll review the results together.**
## Deploy — Multi-Account
### Step A — Deploy Member Roles (management account)
Look up the root OU ID automatically:```bashROOT_OU=$(aws organizations list-roots --profile <mgmt-profile> --region <region> \ --query "Roots[0].Id" --output text)```
Deploy the StackSet:```bashwget https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/1-sat2-member-roles.yaml
aws cloudformation create-stack-set \ --template-body file://1-sat2-member-roles.yaml \ --stack-set-name sat2-member-roles \ --permission-model SERVICE_MANAGED \ --auto-deployment Enabled=true,RetainStacksOnAccountRemoval=false \ --capabilities CAPABILITY_NAMED_IAM \ --parameters ParameterKey=ProwlerAccountID,ParameterValue=<audit-account-id> \ --region <region> --profile <mgmt-profile>
aws cloudformation create-stack-instances \ --stack-set-name sat2-member-roles \ --deployment-targets OrganizationalUnitIds='["'$ROOT_OU'"]' \ --regions '["<region>"]' \ --operation-preferences FailureTolerancePercentage=100,MaxConcurrentPercentage=100 \ --region <region> --profile <mgmt-profile>```
Note: StackSets don't apply to the management account. Deploy `1-sat2-member-roles.yaml` as a regular Stack in the management account if it also needs scanning.
**Wait for completion** — poll until `SUCCEEDED`:```bashOP_ID=$(aws cloudformation list-stack-set-operations --stack-set-name sat2-member-roles \ --query "Summaries[0].OperationId" --output text --profile <mgmt-profile> --region <region>)
aws cloudformation describe-stack-set-operation --stack-set-name sat2-member-roles \ --operation-id $OP_ID --query "StackSetOperation.Status" --output text \ --profile <mgmt-profile> --region <region>```
If `FAILED`/`STOPPED`, check failures:```bashaws cloudformation list-stack-set-operation-results --stack-set-name sat2-member-roles \ --operation-id $OP_ID --query "Summaries[?Status!='SUCCEEDED']" \ --profile <mgmt-profile> --region <region>```
Do NOT proceed until Step A completes.
### Step B — Verify Organizations Access (management account)
Check automatically — do NOT ask the user:```bashaws organizations list-delegated-administrators --profile <mgmt-profile> --region <region>aws organizations describe-resource-policy --profile <mgmt-profile> --region <region>```
- Audit account in delegated admins list → proceed.- Resource policy grants audit account `organizations:ListAccounts` → proceed.- Neither exists → create a resource policy (preferred): ```bash aws organizations put-resource-policy --content \ '{ "Version": "2012-10-17", "Statement": [{ "Sid": "ProwlerListAccounts", "Effect": "Allow", "Principal": {"AWS": "arn:aws:iam::<audit-account-id>:root"}, "Action": ["organizations:ListAccounts","organizations:DescribeAccount","organizations:ListTagsForResource"], "Resource": "*" }] }' --profile <mgmt-profile> --region <region> ``` For GovCloud, use delegated admin: `aws organizations register-delegated-administrator --account-id <audit-account-id>`
### Step C — Deploy SATv2 (audit account)
```bashaws cloudformation deploy \ --template-file 2-sat2-codebuild-prowler.yaml \ --stack-name sat2-prowler \ --capabilities CAPABILITY_NAMED_IAM \ --parameter-overrides MultiAccountScan=true Reporting=true ProwlerScanType=<type> EmailAddress=<email> \ --profile <audit-profile> --region <region>```
After deployment:> **The multi-account scan is running. You'll get an email at `<email>` when it completes (and a second email when the consolidated report is ready). Come back to me then and we'll review together.**
## Review the Results
**Starts when the user returns after the email notification, or when Step 3 detects a completed scan.**
Begin immediately — do NOT ask if they want to review.
### Step 0 — Verify Build Succeeded
Before downloading results, confirm the scan actually completed:
```bashPROJECT=$(aws cloudformation describe-stack-resources --stack-name <stack-name> \ --query "StackResources[?ResourceType=='AWS::CodeBuild::Project'].PhysicalResourceId" \ --output text --profile <profile> --region <region>)
BUILD_ID=$(aws codebuild list-builds-for-project --project-name $PROJECT \ --query "ids[0]" --output text --profile <profile> --region <region>)
aws codebuild batch-get-builds --ids $BUILD_ID \ --query "builds[0].buildStatus" --output text --profile <profile> --region <region>```
- **SUCCEEDED** → proceed to Step 1.- **IN_PROGRESS** → tell the user the scan is still running, come back later.- **FAILED** → show the logs link (`builds[0].logs.deepLink`), offer to re-run or troubleshoot.
### Step 1 — Download Results
```bashBUCKET=$(aws cloudformation describe-stack-resources --stack-name <stack-name> \ --query "StackResources[?LogicalResourceId=='ProwlerFindingsBucket'].PhysicalResourceId" \ --output text --profile <profile> --region <region>)
aws s3 ls s3://$BUCKET/ --recursive --profile <profile> --region <region>
mkdir -p sat2-results/csv sat2-results/complianceaws s3 sync s3://$BUCKET/csv/ sat2-results/csv/ --profile <profile> --region <region>aws s3 sync s3://$BUCKET/compliance/ sat2-results/compliance/ --profile <profile> --region <region>aws s3 sync s3://$BUCKET/ sat2-results/ --exclude "csv/*" --exclude "compliance/*" --profile <profile> --region <region>```
### Step 2 — Open HTML Report
SATv2 includes a static HTML report in the reporting folder that loads the consolidated CSV. Open it directly:```bashopen sat2-results/reports/*.html 2>/dev/null || open sat2-results/**/*.html```
> **SATv2's HTML report is open in your browser — use it to filter and explore findings by severity, account, service, or region. No additional tools to install.**
### Output Files
| File | Use ||------|-----|| `*.html` | Interactive report — loads consolidated CSV for filtering || `*.csv` | Tabular data || `*.json` / `*.json-ocsf` | Machine-readable / OCSF format for Security Hub || `/reports/*.csv` | Consolidated CSV (if Reporting enabled) || `/reports/*.pptx` | SHIP HealthCheck presentation (if Reporting enabled) |
## Clean Up
**After the user finishes reviewing results, proactively recommend cleanup.** SATv2 is a point-in-time tool — once the CodeBuild scan completes, the resources sit idle. Cleaning up removes them from the account.
> **You've got your results downloaded locally and the S3 bucket with reports will be retained. Want me to clean up the SATv2 stack now? It's designed to be temporary — you can always re-deploy it for a fresh scan later.**
If yes (or user confirms), proceed:
**Single account:**```bashaws cloudformation delete-stack --stack-name <stack-name> --profile <profile> --region <region>```
**Multi-account:**```bash# Delete StackSet instances firstaws cloudformation delete-stack-instances --stack-set-name sat2-member-roles \ --deployment-targets OrganizationalUnitIds='["'$ROOT_OU'"]' \ --regions '["<region>"]' --no-retain-stacks \ --profile <mgmt-profile> --region <region>
# Wait for completion, then delete StackSetaws cloudformation delete-stack-set --stack-set-name sat2-member-roles \ --profile <mgmt-profile> --region <region>
# Delete the main stackaws cloudformation delete-stack --stack-name <stack-name> --profile <audit-profile> --region <region>```
Tell the user: **Cleaned up. Your scan results are still in the S3 bucket (`<bucket-name>`) and downloaded locally in `sat2-results/`.**
## Next Steps
After the assessment, recommend:- **Remediate findings with Kiro** — use the Security Hub Remediation Kiro Skill to triage, fix, and track the findings identified by this assessment. Blog walkthrough: [Remediating AWS Security Hub Findings with Kiro Skills](https://builder.aws.com/content/3BT16FE7BgulYKshKicMzXo5NKo/remediating-aws-security-hub-findings-with-kiro-skills)- **Enable AWS Security Hub** — Foundational Security Best Practices for continuous monitoring- **Request a formal SHIP engagement** — https://aws.amazon.com/security/security_start_right_run_well/- **Prowler + Security Hub integration** — https://docs.prowler.cloud/en/latest/tutorials/aws/securityhub/
## Rules
- Always validate AWS profile and account ID with the user before any deployment- Default region: `us-west-2`- Show exact commands before execution; wait for confirmation on CloudFormation deploys- Email is mandatory for all deployments- For multi-account, always recommend enabling Reporting
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article