
grc-portfolio
Build and deploy a professional portfolio website for GRC engineers — certifications, frameworks, audit experience, and AWS hosting.
- version
- 0.1.0
- GitHub stars
- 436
Install
/plugin install grc-portfolio@grc-engineering-suiteRun it inside Claude Code after adding the marketplace with /plugin marketplace add GRCEngClub/claude-grc-engineering.
Contents
Discovered from sourceSkills 7
GRC Portfolio Planner
You are running the /grc-portfolio:plan skill. Your job is to guide a GRC (Governance, Risk & Compliance) engineer through a conversational questionnaire and produce a site-config.json and SITE-PLAN.md configured for a professional GRC portfolio website.
Step 0: Resolve Plugin Root and Project Directory
Locate the plugin's bundled scripts (needed later for toolkitDir):
find ~/.claude -path "*/grc-portfolio/scripts/deploy.sh" 2>/dev/null | head -1
Strip /scripts/deploy.sh from the result to get PLUGIN_ROOT. If nothing is found, ask the user for the path to their local checkout of the grc-portfolio plugin (do not guess a directory layout).
Determine the project directory from $ARGUMENTS. If not provided, ask the user where they want the project created (suggest ~/<their-name>-grc-portfolio or a path under their preferred repos directory). Create the directory if it doesn't exist.
Step 1: Identity
Ask these questions (3–4 at a time, conversationally):
- Full name
- Current job title (e.g., "Senior GRC Engineer", "Information Security Manager", "Compliance Lead")
- Years working in GRC
- Brief professional summary (2–3 sentences they'd use as a bio — you can draft one based on their answers if they want)
- LinkedIn URL
- GitHub URL (optional)
- Personal/professional email (for contact form)
- Location (city/state or remote)
- Do they have a professional headshot? (yes/no — if yes, note the filename they'll drop in the project)
Step 2: GRC Expertise
Ask which frameworks they specialize in. Present the full list — let them pick all that apply:
SOC 2 | ISO 27001 | NIST 800-53 | FedRAMP | PCI-DSS | HIPAA | CMMC | HITRUST |
GDPR | CIS Controls | DORA | StateRAMP | NIST CSF | NYDFS | Essential Eight |
ISMAP | IRAP | PBMM | CSA CCM | GLBA
Also ask:
- Primary specializations (pick all that apply): Compliance auditing, Risk management, Policy development, Compliance engineering/automation, Third-party risk management (TPRM), GRC tooling implementation, Security program management
- Industry verticals they've worked in (SaaS/tech, fintech, healthcare/HIPAA, government/FedRAMP, retail/PCI, critical infrastructure, etc.)
Step 3: Certifications
Ask about certifications. Present common ones as a checklist — let them select active/in-progress:
Active certs (pick all they hold): CISSP, CISA, CISM, CPA, CIA, CRISC, CCSP, CGEIT, CDPSE, Security+, CEH, OSCP, AWS Security Specialty, GCP Security Engineer, Azure Security Engineer, PCIP, QSA
In-progress (optional): what cert are they working toward, and expected completion date?
Step 4: Experience Highlights
Ask:
- Current employer and role (or note they're "open to opportunities" if job searching)
- 3–5 career accomplishments to feature (e.g., "Led SOC 2 Type II audit for a 300-person SaaS company achieving zero material findings", "Reduced evidence collection time by 70% using Python automation", "Implemented FedRAMP Moderate for a federal contractor from scratch in 14 months")
- GRC tools used professionally (Vanta, Drata, Tugboat Logic, Hyperproof, ServiceNow GRC, Archer, OneTrust, Jira, Confluence, Qualys, Tenable, Splunk, CrowdStrike, etc.)
- Specific cloud platforms they've worked with for compliance (AWS, Azure, GCP, multi-cloud)
Step 5: Projects & Writing
Ask:
- Any GRC automation or tooling projects they want to showcase? (name, description, GitHub link, technologies used — e.g., "Built an evidence collector that pulls from AWS Config, Okta, and GitHub into a unified dashboard")
- Published articles, blog posts, or LinkedIn long-form content? (title + URL or publication)
- Conference talks, webinars, or podcast appearances? (event name, topic, year)
- Open-source contributions? (repo + what they contributed)
Let them know these are all optional — skip any that don't apply.
Step 6: Design & AWS Configuration
Ask:
- Color scheme — present options:
- Deep Navy & Slate (default — authoritative, professional GRC aesthetic)
- Dark Mode Charcoal (modern security/tech vibe)
- Clean White & Teal (clean, consulting firm look)
- Custom (let them specify primary + accent color)
- Custom domain? — yes/no. If yes, which domain?
- AWS CLI profile — what profile name? (default: "default")
- Contact form? — yes/no (uses AWS Lambda + SES; requires SES setup). If yes, also collect:
aws.sesFromEmail: SES-verified sender identity to use asSourceaws.sesToEmail: inbox where contact-form submissions are delivered The infra step will refuse to deploy the contact-form stack without both. Warn the user that they must verify these addresses in SES (or move out of SES sandbox) before the form can send mail.
- Any other pages they want beyond the standard portfolio sections? (Speaking page, Publications page, GRC Tools page, etc.)
Step 7: Generate site-config.json
Read the template from <PLUGIN_ROOT>/templates/site-config-template.json.
Create a site-config.json in the project directory populated with all gathered information:
{
"projectName": "<kebab-case name>",
"projectDir": "<absolute path>",
"toolkitDir": "<PLUGIN_ROOT>",
"siteType": "portfolio",
"client": {
"name": "<full name>",
"title": "<job title>",
"email": "<email>",
"location": "<location>",
"linkedin": "<url>",
"github": "<url or null>",
"yearsInGrc": <number>,
"summary": "<professional bio>"
},
"grc": {
"frameworks": ["SOC2", "ISO27001", ...],
"specializations": ["Compliance auditing", ...],
"industries": ["SaaS/tech", ...],
"tools": ["Vanta", "Drata", ...]
},
"certifications": {
"active": ["CISSP", "CISA", ...],
"inProgress": [{"name": "CCSP", "expectedDate": "2025-Q3"}]
},
"portfolio": {
"accomplishments": ["Led SOC 2 Type II...", ...],
"projects": [
{
"name": "<project name>",
"description": "<description>",
"technologies": ["Python", "AWS"],
"url": "<github url or null>"
}
],
"speaking": [
{"event": "<event>", "topic": "<topic>", "year": 2024, "url": null}
],
"articles": [
{"title": "<title>", "publication": "<pub>", "url": "<url>"}
],
"openSource": []
},
"design": {
"colorScheme": "navy-slate",
"primaryColor": "#1e3a5f",
"accentColor": "#64748b",
"style": "professional"
},
"pages": ["home", "about", "frameworks", "certifications", "projects", "contact"],
"features": {
"customDomain": false,
"contactForm": false
},
"aws": {
"profile": "default",
"region": "us-east-1",
"stackName": "<projectName>-website",
"domain": null
},
"status": {
"planComplete": true,
"buildComplete": false,
"infraDeployed": false,
"siteDeployed": false
}
}
Set toolkitDir to PLUGIN_ROOT (the plugin's own directory). Set status.planComplete = true.
Step 8: Generate SITE-PLAN.md
Read <PLUGIN_ROOT>/templates/SITE-PLAN-TEMPLATE.md as reference. Create a SITE-PLAN.md in the project directory that includes:
- Professional summary and positioning statement
- All GRC frameworks and credentials to feature
- Certifications list with badge recommendations
- Career highlights and accomplishments
- Projects to showcase with descriptions
- Speaking/writing/open-source contributions
- Design choices and color palette
- Planned page structure
- AWS configuration summary
- Next steps (run
/grc-portfolio:buildthen/grc-portfolio:preflight)
Step 9: Summary
Tell the user:
- Where
site-config.jsonandSITE-PLAN.mdwere created - Suggest they review
SITE-PLAN.mdand make any edits before building - Next command:
/grc-portfolio:buildto scaffold the React project - Full workflow:
plan → build → preflight → infra → deploy → repo → cicd
Variables
PLUGIN_ROOT= resolved fromfind ~/.claude -path "*/grc-portfolio/scripts/deploy.sh". If not found, prompt the user for the path to their local checkout of the plugin.$ARGUMENTS= arguments passed after/plan(expected: project directory path)
Website Build Skill
You are running the /grc-portfolio:build skill. Your job is to scaffold a complete, production-ready React/Vite website from the site-config.json created by /grc-portfolio:plan.
Step 1: Locate and Validate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it and validate that status.planComplete === true. If not, tell the user to run /grc-portfolio:plan first.
Read the siteType field to determine which components to generate.
Step 2: Scaffold Project Structure
Create the following structure in the project directory:
src/
main.jsx
App.jsx
App.css
index.css
components/
Navbar.jsx
Hero.jsx
Footer.jsx
ContactForm.jsx (if features.contactForm)
... (type-specific components)
assets/
index.html (Vite's entry HTML, references /src/main.jsx)
public/
favicon.svg
package.json
vite.config.js
.env.example
.gitignore
Step 3: Generate package.json
Base it on the toolkit's examples/package.json at $TOOLKIT_DIR/examples/package.json. Customize:
- Set
nameto theprojectNamefrom config - Keep all dependencies the same (react, react-dom, react-router-dom)
- Keep all devDependencies the same
Step 4: Generate vite.config.js
Copy from $TOOLKIT_DIR/examples/vite.config.js as-is. It's already well-configured for AWS deployment.
Step 5: Generate Components by Site Type
All Types (shared components)
Navbar.jsx -- Navigation bar with:
- Site name/logo on the left
- Navigation links based on
pagesarray from config - Mobile-responsive hamburger menu
- Smooth scroll to sections
Hero.jsx -- Full-width hero section with:
- Main heading (name/company/product depending on type)
- Subtitle/tagline
- CTA button(s) based on
design.ctaPreference - Background using the color scheme
Footer.jsx -- Footer with:
- Copyright notice
- Social links (if available)
- Quick navigation links
ContactForm.jsx (if features.contactForm):
- Form with name, email, company (optional), message fields
- Submits to
VITE_CONTACT_API_ENDPOINTenv var - Loading state, success/error feedback
- Basic client-side validation
Portfolio/Personal Components
- About.jsx -- Professional summary, photo placeholder
- Skills.jsx -- Skills organized by category in a grid
- Projects.jsx -- Project cards with descriptions, tech tags, links
- Certifications.jsx -- Certification badges/list
- Speaking.jsx -- Talks, podcasts, articles (if data provided)
Business Landing Page Components
- Services.jsx -- Service cards with descriptions
- Testimonials.jsx -- Testimonial cards with quotes
- Team.jsx -- Team member cards
- Pricing.jsx -- Pricing tier cards (if data provided)
SaaS Marketing Components
- Features.jsx -- Feature grid with icons and descriptions
- Pricing.jsx -- Pricing comparison table/cards
- Integrations.jsx -- Integration logos/grid
- CTA.jsx -- Call-to-action section with demo/signup buttons
Brochure Components
- About.jsx -- Business description
- Services.jsx -- Service list
- Hours.jsx -- Business hours and location/map placeholder
Step 6: Generate Styles
index.css
CSS reset and base styles. Set CSS custom properties based on design.colorScheme:
navy-slate (GRC default):
--color-primary: #1e3a5f;
--color-primary-dark: #152a45;
--color-secondary: #64748b;
--color-accent: #3b82f6;
--color-bg: #ffffff;
--color-bg-alt: #f8fafc;
--color-text: #1e293b;
--color-text-light: #64748b;
dark-charcoal:
--color-primary: #818cf8;
--color-primary-dark: #6366f1;
--color-secondary: #94a3b8;
--color-accent: #22d3ee;
--color-bg: #0f172a;
--color-bg-alt: #1e293b;
--color-text: #f1f5f9;
--color-text-light: #94a3b8;
white-teal:
--color-primary: #0d9488;
--color-primary-dark: #0f766e;
--color-secondary: #64748b;
--color-accent: #06b6d4;
--color-bg: #ffffff;
--color-bg-alt: #f0fdfa;
--color-text: #1e293b;
--color-text-light: #64748b;
If design.colorScheme is "custom", use design.primaryColor and design.accentColor from config and derive the rest.
App.css
Component-level styles. Use the CSS custom properties from index.css. Style should match design.style:
- professional: Conservative layout, clean typography, authoritative feel
- bold-modern: Strong colors, larger typography, prominent shadows
- clean-minimal: Lots of whitespace, thin borders, subtle shadows
Step 7: Generate main.jsx and App.jsx
main.jsx:
import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App.jsx'
import './index.css'
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
<App />
</React.StrictMode>,
)
App.jsx: Import and compose all generated components in order. Use a single-page layout with sections. Include smooth scrolling.
Step 8: Generate index.html
Write this file at the project root (<projectDir>/index.html), not under public/. Vite resolves the entry HTML from the project root, and /src/main.jsx is referenced as an absolute project-root path:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="description" content="{{site description from config}}" />
<title>{{site title from config}}</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>
Step 9: Generate .env.example and .gitignore
.env.example:
# Contact Form API endpoint (from /grc-portfolio:infra deployment)
VITE_CONTACT_API_ENDPOINT=
.gitignore:
node_modules
dist
.env
.env.local
.DS_Store
*.log
Step 10: Copy Lambda Function (if contact form)
If features.contactForm is true, copy $TOOLKIT_DIR/lambda/contact-form-handler.js into a lambda/ directory in the project.
Step 11: Install and Verify
Run:
cd <projectDir>
npm install
npm run build
If the build fails, fix the errors. Common issues:
- Import paths
- Missing dependencies
- JSX syntax errors
Step 12: Update Config
Update site-config.json:
- Set
status.buildComplete = true
Step 13: Summary
Tell the user:
- The project has been scaffolded at
<projectDir> - List the files created
- Tell them they can run
npm run devto preview locally - Suggest running
/grc-portfolio:preflightnext to check AWS readiness
Important Guidelines
- Populate real content from site-config.json -- don't use placeholder "Lorem ipsum" text. Use the actual names, descriptions, certifications, frameworks, projects, etc. that the user provided.
- Make it look good -- the generated site should be visually polished and production-ready out of the box.
- Responsive -- all components must work on mobile, tablet, and desktop.
- Accessible -- use semantic HTML, proper heading hierarchy, alt text, aria labels.
- Keep it simple -- vanilla React with CSS. No CSS frameworks unless the user specifically requests one.
Variables
$TOOLKIT_DIR= read fromsite-config.jsontoolkitDirfield$ARGUMENTS= arguments passed after/build(expected: project directory path)
Website CI/CD Skill
You are running the /grc-portfolio:cicd skill. Your job is to set up a GitHub Actions workflow that automatically deploys the website to AWS whenever code is pushed to the main branch, using GitHub OIDC for secure, keyless AWS authentication.
Step 1: Locate and Validate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it and validate:
status.repoCreated === true(if not, tell user to run/grc-portfolio:repofirst)status.infraDeployed === true(if not, tell user to run/grc-portfolio:infrafirst)
Step 2: Set Up GitHub OIDC IAM Role
2a: Ensure OIDC Provider Exists
Check if the GitHub OIDC identity provider already exists in the AWS account:
aws iam list-open-id-connect-providers --profile <aws.profile>
Look for token.actions.githubusercontent.com. If it doesn't exist, create it:
aws iam create-open-id-connect-provider \
--url https://token.actions.githubusercontent.com \
--client-id-list sts.amazonaws.com \
--thumbprint-list 6938fd4d98bab03faadb97b34396831e3780aea1 \
--profile <aws.profile>
2b: Create IAM Role with Trust Policy
Create a trust policy that allows only this specific GitHub repo's main
branch (and workflow_dispatch runs against main) to assume the role.
The :* wildcard is too broad — it would let any PR, tag, or environment
in the repo assume this role.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::<account-id>:oidc-provider/token.actions.githubusercontent.com"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
"token.actions.githubusercontent.com:sub": "repo:<github.owner>/<github.repoName>:ref:refs/heads/main"
}
}
}
]
}
If the project deploys from a different branch, replace main accordingly.
For preview deploys from PRs, add a second statement scoped to
repo:<owner>/<repo>:pull_request and a separate, narrower IAM policy.
Create the role:
aws iam create-role \
--role-name <projectName>-github-deploy \
--assume-role-policy-document file:///tmp/<projectName>-trust-policy.json \
--description "GitHub Actions OIDC role for <projectName> website deployment" \
--profile <aws.profile>
2c: Attach Least-Privilege Deploy Policy
Create an inline policy scoped to only the S3 bucket and CloudFront distribution for this project:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "S3Deploy",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::<aws.bucketName>",
"arn:aws:s3:::<aws.bucketName>/*"
]
},
{
"Sid": "CloudFrontInvalidate",
"Effect": "Allow",
"Action": "cloudfront:CreateInvalidation",
"Resource": "arn:aws:cloudfront::<account-id>:distribution/<aws.distributionId>"
}
]
}
Attach it:
aws iam put-role-policy \
--role-name <projectName>-github-deploy \
--policy-name <projectName>-deploy-access \
--policy-document file:///tmp/<projectName>-deploy-policy.json \
--profile <aws.profile>
Step 3: Create Workflow File
Create .github/workflows/deploy.yml in the project directory.
The workflow uses OIDC — no static AWS keys needed. Bucket name, distribution ID, and role ARN are stored as workflow env vars (not secrets, since they're not sensitive):
name: Deploy to AWS
on:
push:
branches:
- main
workflow_dispatch:
permissions:
id-token: write
contents: read
env:
AWS_BUCKET_NAME: <aws.bucketName>
AWS_DISTRIBUTION_ID: <aws.distributionId>
AWS_REGION: us-east-1
AWS_ROLE_ARN: arn:aws:iam::<account-id>:role/<projectName>-github-deploy
jobs:
deploy:
name: Build and Deploy
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Build project
run: npm run build
env:
NODE_ENV: production
- name: Configure AWS credentials (OIDC)
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ env.AWS_ROLE_ARN }}
aws-region: ${{ env.AWS_REGION }}
- name: Deploy to S3
run: |
aws s3 sync dist/ s3://${{ env.AWS_BUCKET_NAME }} \
--delete \
--cache-control "public,max-age=31536000,immutable" \
--exclude "index.html" \
--exclude "*.html"
aws s3 sync dist/ s3://${{ env.AWS_BUCKET_NAME }} \
--cache-control "public,max-age=0,must-revalidate" \
--exclude "*" \
--include "*.html"
- name: Invalidate CloudFront
run: |
aws cloudfront create-invalidation \
--distribution-id ${{ env.AWS_DISTRIBUTION_ID }} \
--paths "/*"
If features.contactForm is true, add to the Build step's env:
env:
NODE_ENV: production
VITE_CONTACT_API_ENDPOINT: <aws.contactApiEndpoint>
Step 4: Commit and Push
cd <projectDir>
git add .github/workflows/deploy.yml
git commit -m "Add GitHub Actions deploy workflow (OIDC auth)"
git push
Step 5: Verify Workflow
Check that the workflow was triggered:
gh run list --limit 1
If the run is in progress, tell the user. If it completed, report the status:
gh run view <run-id>
Step 6: Update Config
Update site-config.json:
- Set
github.secretsConfigured = true - Set
status.cicdConfigured = true
Step 7: Summary
Tell the user:
- GitHub Actions CI/CD is configured with OIDC (no static AWS keys)
- IAM role
<projectName>-github-deployis scoped to only S3 + CloudFront for this project - Every push to
mainwill automatically build and deploy the site - The workflow can also be triggered manually from the GitHub UI (workflow_dispatch)
- Provide the direct link:
<github.repoUrl>/actions
Variables
$TOOLKIT_DIR= read fromsite-config.jsontoolkitDirfield$ARGUMENTS= arguments passed after/cicd(expected: project directory path)
Website Deploy Skill
You are running the /grc-portfolio:deploy skill. Your job is to build the website and deploy it to the AWS infrastructure created by /grc-portfolio:infra.
Step 1: Locate and Validate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it and validate that status.infraDeployed === true. If not, tell the user to run /grc-portfolio:infra first.
Also validate that status.buildComplete === true. If not, tell the user to run /grc-portfolio:build first.
Extract needed values:
aws.bucketNameaws.distributionIdaws.profileaws.contactApiEndpoint(if contact form enabled)aws.cloudFrontUrlaws.domain(if custom domain)
Step 2: Set Environment Variables (if contact form)
If features.contactForm is true and aws.contactApiEndpoint is set, ensure
.env in the project directory contains:
VITE_CONTACT_API_ENDPOINT=<aws.contactApiEndpoint>
Update the file non-destructively — do not overwrite an existing .env:
- If
.envdoes not exist, create it with just this line. - If
.envexists and already has aVITE_CONTACT_API_ENDPOINT=line, replace only that line. - If
.envexists but does not containVITE_CONTACT_API_ENDPOINT=, append the line.
Preserve any other variables the user has set (e.g. VITE_GA_ID, analytics keys, feature flags).
Step 3: Build the Site
cd <projectDir>
npm run build
Verify the dist/ directory was created and contains files.
If the build fails, diagnose and fix the issue.
Step 4: Deploy to AWS
Use the toolkit's deploy script:
$TOOLKIT_DIR/scripts/deploy.sh <aws.bucketName> <aws.distributionId> <aws.profile>
Run this from the project directory (it expects dist/ in the current working directory).
Step 5: Verify Deployment
Wait a moment for CloudFront to propagate, then tell the user their site is live.
Provide the URL:
- If custom domain:
https://<aws.domain> - Otherwise:
https://<aws.cloudFrontUrl>
Step 6: Update Config
Update site-config.json:
- Set
status.siteDeployed = true
Step 7: Summary
Tell the user:
- The site is deployed and live
- Provide the live URL
- Note that CloudFront cache invalidation takes 1-2 minutes to fully propagate
- Suggest running
/grc-portfolio:repoto create a GitHub repo (if not done) - Suggest running
/grc-portfolio:cicdto set up automatic deployments on push
Variables
$TOOLKIT_DIR= read fromsite-config.jsontoolkitDirfield$ARGUMENTS= arguments passed after/deploy(expected: project directory path)
Website Infrastructure Skill
You are running the /grc-portfolio:infra skill. Your job is to deploy the AWS infrastructure needed to host the website using CloudFormation.
Step 1: Locate and Validate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it and validate that status.preflightComplete === true. If not, tell the user to run /grc-portfolio:preflight first.
Step 2: Choose Template
Based on features.customDomain:
- With custom domain: Use
$TOOLKIT_DIR/cloudformation/website-infrastructure.yaml - Without custom domain: Use
$TOOLKIT_DIR/cloudformation/website-infrastructure-no-domain.yaml
Step 3: Validate Template
Run the validation script:
$TOOLKIT_DIR/scripts/validate-stack.sh <template-path> <aws.profile>
If validation fails, report the error and stop.
Step 4: Deploy Main Stack
Use aws cloudformation deploy — it is idempotent (creates the stack on
first run, applies a change-set on subsequent runs) and waits for completion
inline, so the user doesn't need a separate wait step.
With custom domain:
aws cloudformation deploy \
--stack-name <aws.stackName> \
--template-file <template-path> \
--parameter-overrides \
ProjectName=<projectName> \
DomainName=<aws.domain> \
HostedZoneId=<aws.hostedZoneId> \
CertificateArn=<aws.certArn> \
--profile <aws.profile> \
--region us-east-1 \
--no-fail-on-empty-changeset
Without custom domain:
aws cloudformation deploy \
--stack-name <aws.stackName> \
--template-file <template-path> \
--parameter-overrides ProjectName=<projectName> \
--profile <aws.profile> \
--region us-east-1 \
--no-fail-on-empty-changeset
Note: Check the actual template parameters first by reading the template file, as parameter names may differ from the examples above. Use the actual parameter names from the template.
The deploy command can take 5-15 minutes (especially with CloudFront distribution creation). Tell the user it's in progress and approximately how long it might take.
If the deploy fails, retrieve the failure reason:
aws cloudformation describe-stack-events \
--stack-name <aws.stackName> \
--profile <aws.profile> \
--region us-east-1 \
--query "StackEvents[?ResourceStatus=='CREATE_FAILED' || ResourceStatus=='UPDATE_FAILED'].[LogicalResourceId,ResourceStatusReason]" \
--output table
Step 6: Retrieve Stack Outputs
aws cloudformation describe-stacks \
--stack-name <aws.stackName> \
--profile <aws.profile> \
--region us-east-1 \
--query "Stacks[0].Outputs"
Extract and save to site-config.json:
aws.bucketName-- the S3 bucket nameaws.distributionId-- the CloudFront distribution IDaws.cloudFrontUrl-- the CloudFront domain name (e.g., d123abc.cloudfront.net)
Step 7: Deploy Contact Form API (if enabled)
If features.contactForm is true:
-
Ask the user for two SES-verified email addresses (no defaults — the stack will refuse to deploy without them):
SESFromEmail: verified sender identitySESToEmail: recipient inbox for submissions
If either is not yet verified in SES, stop and instruct the user to verify them in the AWS Console (
SES → Verified identities → Create identity) before continuing. Save both toaws.sesFromEmailandaws.sesToEmailinsite-config.json. -
Deploy the contact form stack:
aws cloudformation deploy \
--template-file $TOOLKIT_DIR/cloudformation/contact-form-api.yaml \
--stack-name <projectName>-contact-form-api \
--parameter-overrides "SESFromEmail=<aws.sesFromEmail>" "SESToEmail=<aws.sesToEmail>" \
--capabilities CAPABILITY_IAM \
--profile <aws.profile> \
--region us-east-1 \
--no-fail-on-empty-changeset
- Retrieve the API endpoint:
aws cloudformation describe-stacks \
--stack-name <projectName>-contact-form-api \
--profile <aws.profile> \
--region us-east-1 \
--query "Stacks[0].Outputs[?OutputKey=='ApiEndpoint'].OutputValue" \
--output text
-
Save to
aws.contactApiEndpointin config. -
Package and deploy the Lambda function code (reference
$TOOLKIT_DIR/scripts/deploy-contact-api.shfor the pattern -- create temp dir, copy handler, install @aws-sdk/client-ses, zip, update function code). The function name is<projectName>-contact-form-api-handler(derived from the stack name in the template).
Step 8: Domain Instructions (if custom domain)
If using a custom domain, tell the user:
- The nameservers they need to set at their domain registrar
- How to verify DNS propagation:
dig NS <domain> - That DNS propagation can take up to 48 hours (usually much faster)
Get the nameservers:
aws route53 get-hosted-zone --id <aws.hostedZoneId> --profile <aws.profile> --query "DelegationSet.NameServers"
Step 9: Update Config
Update site-config.json:
- Set
aws.bucketName,aws.distributionId,aws.cloudFrontUrl - Set
aws.contactApiEndpoint(if contact form) - Set
status.infraDeployed = true
Step 10: Summary
Tell the user:
- Infrastructure deployed successfully
- CloudFront URL where the site will be accessible
- Contact form API endpoint (if applicable)
- DNS instructions (if custom domain)
- Suggest running
/grc-portfolio:deploynext to push the built site to AWS
Variables
$TOOLKIT_DIR= read fromsite-config.jsontoolkitDirfield$ARGUMENTS= arguments passed after/infra(expected: project directory path)
Website Preflight Skill
You are running the /grc-portfolio:preflight skill. Your job is to validate that all prerequisites are met for deploying a website to AWS, and guide the user through any human tasks required.
Step 1: Locate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it to understand what features are enabled and what AWS configuration is needed.
Step 2: Automated Checks
Run each check and record the result as PASS or FAIL:
Required Checks (all deployments)
-
AWS CLI installed
aws --versionIf missing: suggest running
$TOOLKIT_DIR/scripts/bootstrap.sh -
Node.js installed (v18+)
node --version -
npm installed
npm --version -
AWS credentials configured
aws sts get-caller-identity --profile <aws.profile>Record the account ID and ARN for the report.
-
AWS region set to us-east-1 Verify
aws.regionin config isus-east-1(required for CloudFront + ACM). -
CloudFormation templates valid Run
$TOOLKIT_DIR/scripts/validate-stack.shagainst the appropriate template:- If
features.customDomain: validate$TOOLKIT_DIR/cloudformation/website-infrastructure.yaml - Otherwise: validate
$TOOLKIT_DIR/cloudformation/website-infrastructure-no-domain.yaml
- If
Conditional Checks
-
SES email verified (if
features.contactForm)aws ses get-identity-verification-attributes --identities <client.email> --profile <aws.profile> --region us-east-1Check that the status is "Success".
-
Route 53 hosted zone exists (if
features.customDomain)aws route53 list-hosted-zones-by-name --dns-name <aws.domain> --profile <aws.profile>If found, save the hosted zone ID to
aws.hostedZoneIdin config. -
ACM certificate exists in us-east-1 (if
features.customDomain)aws acm list-certificates --region us-east-1 --profile <aws.profile> --query "CertificateSummaryList[?DomainName=='<aws.domain>']"If found and status is "ISSUED", save the ARN to
aws.certArnin config. -
gh CLI installed (for future /grc-portfolio:repo and /grc-portfolio:cicd steps)
gh --version
Step 3: Produce Report
Output a formatted report with three sections:
PASS
List all checks that passed with a checkmark.
ACTION REQUIRED (Automated)
Things that can be fixed automatically -- offer to run the fix:
- Missing tools (run bootstrap.sh)
- Template validation (fix template issues)
ACTION REQUIRED (Human)
Things the user must do manually. For each, provide:
- What to do (clear instructions)
- AWS Console URL (direct link where possible)
- Expected time (rough estimate)
- Verification command (how to check it's done)
Common human tasks:
- Create AWS account: https://aws.amazon.com/ -- sign up, create IAM user with AdministratorAccess
- Buy/transfer domain to Route 53: https://console.aws.amazon.com/route53/home#/DomainRegistration
- Request ACM certificate: https://console.aws.amazon.com/acm/home?region=us-east-1#/certificates/request -- request for the domain + *.domain, use DNS validation
- Verify email in SES: https://console.aws.amazon.com/ses/home?region=us-east-1#/verified-identities -- add email, click verification link
- Install gh CLI:
brew install gh && gh auth login
Step 4: Wait for Human Tasks
If there are human action items, tell the user to complete them and then say "ready" or "done" to re-run the checks.
When they indicate completion, re-run only the previously-failed checks.
Step 5: Update Config
Once all checks pass:
- Update
aws.hostedZoneIdif discovered - Update
aws.certArnif discovered - Set
status.preflightComplete = true - Write the updated
site-config.json
Step 6: Summary
Tell the user:
- All preflight checks passed
- Suggest running
/grc-portfolio:buildnext (if not done) or/grc-portfolio:infrato deploy infrastructure
Variables
$TOOLKIT_DIR= read fromsite-config.jsontoolkitDirfield$ARGUMENTS= arguments passed after/grc-portfolio:preflight(expected: project directory path)
Website Repo Skill
You are running the /grc-portfolio:repo skill. Your job is to create a GitHub repository for the website project and push the code.
Step 1: Locate and Validate Config
Find site-config.json:
- Check
$ARGUMENTSfor a project directory path - Check the current working directory
- Ask the user if not found
Read it and validate that status.buildComplete === true. If not, tell the user to run /grc-portfolio:build first.
Step 2: Verify Prerequisites
Check that gh CLI is installed and authenticated:
gh --version
gh auth status
If not installed, tell the user to run:
brew install gh
gh auth login
Step 3: Ask Repository Details
Ask the user:
- Repo name (suggest
projectNamefrom config) - Visibility: public or private (default: private)
Step 4: Ensure .gitignore
Check if .gitignore exists in the project directory. If not, create one:
# Dependencies
node_modules/
# Build output
dist/
# Environment variables
.env
.env.local
.env.production
# OS files
.DS_Store
Thumbs.db
# IDE
.vscode/
.idea/
# Logs
*.log
npm-debug.log*
# Lambda packages
lambda/*.zip
If it exists, verify it includes at least node_modules, dist, .env, .env.local, and .DS_Store. If any of those entries are missing, add them before staging any files — git add -A will happily stage .env.local with secrets in it otherwise.
Step 5: Initialize Git and Commit
cd <projectDir>
git init
Before staging, confirm .env* files are ignored:
git check-ignore -q .env .env.local 2>/dev/null && echo "ok: env files ignored"
If that fails (exit code 1), stop and fix .gitignore — do not run git add -A until env files are ignored.
git add -A
# Sanity check: nothing under .env* should be staged.
if git diff --cached --name-only | grep -E '^\.env(\.|$)'; then
echo "ERROR: env file staged — unstage it and fix .gitignore" >&2
exit 1
fi
git commit -m "Initial commit: scaffolded GRC portfolio website"
Step 6: Create GitHub Repo and Push
gh repo create <repoName> --<visibility> --source . --push
This creates the repo on GitHub, sets the remote, and pushes the code.
Step 7: Update Config
Get the repo URL and owner:
gh repo view --json url,owner
Update site-config.json:
- Set
github.repoNameto the repo name - Set
github.repoUrlto the full URL - Set
github.ownerto the owner login - Set
github.visibilityto public/private - Set
status.repoCreated = true
Step 8: Summary
Tell the user:
- The repo was created at
<github.repoUrl> - The code has been pushed
- Suggest running
/grc-portfolio:infranext (if not done) or/grc-portfolio:cicdto set up continuous deployment
Variables
$ARGUMENTS= arguments passed after/repo(expected: project directory path)
Commands 7
GRC Portfolio Build
Generates a complete React/Vite project from the site-config.json created by /grc-portfolio:plan. Components are pre-populated with your actual GRC content — no placeholder text.
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
What It Creates
src/
components/
Navbar.jsx
Hero.jsx
About.jsx
Frameworks.jsx ← GRC frameworks you specialize in
Certifications.jsx ← Active and in-progress certs
Projects.jsx ← GRC automation projects
Speaking.jsx ← Talks, articles, podcasts
ContactForm.jsx ← (if contact form enabled)
Footer.jsx
main.jsx
App.jsx
index.css
index.html ← (Vite's entry HTML lives at the project root)
public/
favicon.svg
package.json
vite.config.js
Prerequisite
Run /grc-portfolio:plan first to create site-config.json.
Example
/grc-portfolio:build ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:build
Next Step
Preview locally with npm run dev, then run /grc-portfolio:preflight to validate AWS readiness.
Set Up CI/CD
Configures fully automated deployments using GitHub Actions and GitHub OIDC. No static AWS access keys stored anywhere — the workflow assumes a least-privilege IAM role via OIDC token.
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
What It Does
- Creates (or verifies) the GitHub OIDC provider in your AWS account
- Creates an IAM role scoped to only your S3 bucket and CloudFront distribution
- Generates
.github/workflows/deploy.yml— triggers on push tomainandworkflow_dispatch - Commits and pushes the workflow file
- Verifies the first run completes successfully
Prerequisites
/grc-portfolio:repomust have run (status.repoCreated === true)/grc-portfolio:inframust have run (status.infraDeployed === true)
Example
/grc-portfolio:cicd ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:cicd
After this, every git push to main automatically builds and deploys your portfolio.
Deploy Site
Runs the full deployment pipeline in three steps:
npm run build— builds the React/Vite project todist/aws s3 sync— uploads files to your S3 bucketaws cloudfront create-invalidation— clears the CDN cache
Your live URL is printed at the end.
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
Prerequisites
/grc-portfolio:buildmust have run (status.buildComplete === true)/grc-portfolio:inframust have run (status.infraDeployed === true)
Example
/grc-portfolio:deploy ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:deploy
Next Steps
- Run
/grc-portfolio:repoto push code to GitHub - Run
/grc-portfolio:cicdto set up automatic deploys on every push tomain
Deploy Infrastructure
Provisions all AWS infrastructure needed to host your GRC portfolio using CloudFormation:
- S3 bucket — stores your built website files
- CloudFront distribution — global CDN with HTTPS
- Route 53 + ACM certificate — custom domain with SSL (if configured)
- Lambda + API Gateway — contact form backend (if configured)
Deployment takes ~5–15 minutes. Stack outputs (bucket name, distribution ID, CloudFront URL) are automatically saved back to site-config.json.
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
Prerequisite
Run /grc-portfolio:preflight first. All checks must pass.
Example
/grc-portfolio:infra ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:infra
Next Step
Run /grc-portfolio:deploy to build and push your site to the new infrastructure.
GRC Portfolio Plan
Guides a GRC engineer through building a professional portfolio website plan. Asks about frameworks mastered, certifications held, career accomplishments, GRC tools used, projects, and published work — then produces a site-config.json and SITE-PLAN.md ready for the build step.
Arguments
$1— Target project directory (optional; prompted if not provided)
What It Produces
site-config.json— Full site configuration with all GRC content, design choices, and AWS settingsSITE-PLAN.md— Human-readable summary to review before building
Example
/grc-portfolio:plan ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:plan
Next Step
After reviewing SITE-PLAN.md, run /grc-portfolio:build to scaffold the React project.
AWS Preflight Check
Runs 10 automated checks against your AWS environment to verify everything is ready for deployment. Produces a three-section report: PASS, ACTION AUTOMATED, and ACTION HUMAN (with console links and estimated time for each).
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
Checks Run
- AWS CLI installed
- Node.js v18+ installed
- npm installed
- AWS credentials valid (
aws sts get-caller-identity) - Region set to
us-east-1(required for CloudFront + ACM) - CloudFormation template valid
- SES email verified (if contact form enabled)
- Route 53 hosted zone exists (if custom domain)
- ACM certificate issued in us-east-1 (if custom domain)
ghCLI installed (for repo/cicd steps)
Example
/grc-portfolio:preflight ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:preflight
Next Step
Once all checks pass, run /grc-portfolio:infra to deploy the AWS infrastructure.
Create GitHub Repository
Creates a new GitHub repo for your portfolio project, initializes git, and pushes the code. Uses the gh CLI.
Arguments
$1— Project directory containingsite-config.json(optional; defaults to current directory)
What It Does
- Verifies
ghCLI is installed and authenticated - Asks for repo name (suggests
projectNamefrom config) and visibility (public/private) - Creates
.gitignoreif not present git init+ initial commitgh repo create— creates the repo, sets remote, pushes
Saves repo URL and owner to site-config.json.
Prerequisite
Run /grc-portfolio:build first (status.buildComplete === true).
Example
/grc-portfolio:repo ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:repo
Next Step
Run /grc-portfolio:cicd to set up automatic deployment on push to main.
Sponsors
Details
- Marketplace
- GRCEngClub/claude-grc-engineering
- Source
- plugins/grc-portfolio
- Category
- Community
More from GRCEngClub/claude-grc-engineering
All 70- grc-reporterv0.1.0
- grc-tprmv0.1.0
- hitrustv0.1.0
- ind-dpdpav0.1.0
- irapv0.1.0
- ismapv0.1.0
- iso27001v0.1.0
- jp-appiv0.1.0
- nist-800-53v0.1.0
- nist-ai-600-1v0.1.0
- nist-ai-rmfv0.1.0
- nist-csf-20v0.1.0
- nydfsv0.1.0
- okta-inspectorv0.1.0
- onepassword-connectorv0.1.0
- oscalv0.1.0
- pbmmv0.1.0
- pci-dssv0.1.0
- poam-automationv0.1.0
- sg-mas-trmv0.1.0
- singapore-pdpav0.1.0
- slack-inspectorv0.1.0
- snowflake-inspectorv0.1.0
- soc2v0.1.0