AWS Builder Center

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.

Senior Applied AI Solutions Architect
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

  •  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:
  1. Create a folder:  .kiro/skills/satv2-assessment/ 
  1. Create a file inside it:  SKILL.md 
  1. 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:
  1. Downloads the latest SATv2 CloudFormation template from GitHub
  1. Deploys it with the right parameters based on your choices
  1. A Lambda function auto-triggers the CodeBuild project
  1. CodeBuild runs the assessment
  1. Results are uploaded to an S3 bucket
  1. 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:
  1. Compares the deployed template against the latest version on GitHub — so you know if you're running an outdated version
  1. 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

  1. Add the skill, start assessing — no scripts to install, no infrastructure to pre-configure. The skill is a single  SKILL.md  that teaches Kiro the entire SATv2 assessment workflow.
  1. 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.
  1. 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.
  1. 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.
  1. 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-assessment
description: 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:
```bash
aws configure list-profiles
```

If no profiles exist or the user needs a new one, guide through SSO setup:
```bash
aws 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:
```bash
aws 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:

```bash
aws 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 template
aws cloudformation get-template --stack-name <stack-name> \
--profile <profile> --region <region> \
--query "TemplateBody" --output text > /tmp/sat2-deployed.yaml

# Get latest template from GitHub
curl -sL https://raw.githubusercontent.com/awslabs/aws-security-assessment-solution/main/2-sat2-codebuild-prowler.yaml > /tmp/sat2-latest.yaml

# Compare
diff /tmp/sat2-deployed.yaml /tmp/sat2-latest.yaml
```

#### 3b. Check CodeBuild scan status

```bash
PROJECT=$(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

```bash
wget 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:
```bash
ROOT_OU=$(aws organizations list-roots --profile <mgmt-profile> --region <region> \
--query "Roots[0].Id" --output text)
```

Deploy the StackSet:
```bash
wget 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`:
```bash
OP_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:
```bash
aws 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:
```bash
aws 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)

```bash
aws 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:

```bash
PROJECT=$(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

```bash
BUCKET=$(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/compliance
aws 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:
```bash
open 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:**
```bash
aws cloudformation delete-stack --stack-name <stack-name> --profile <profile> --region <region>
```

**Multi-account:**
```bash
# Delete StackSet instances first
aws 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 StackSet
aws cloudformation delete-stack-set --stack-set-name sat2-member-roles \
--profile <mgmt-profile> --region <region>

# Delete the main stack
aws 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

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article