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-suite

Run it inside Claude Code after adding the marketplace with /plugin marketplace add GRCEngClub/claude-grc-engineering.

Contents

Discovered from source

Skills 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:

  1. 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)
  2. Custom domain? — yes/no. If yes, which domain?
  3. AWS CLI profile — what profile name? (default: "default")
  4. Contact form? — yes/no (uses AWS Lambda + SES; requires SES setup). If yes, also collect:
    • aws.sesFromEmail: SES-verified sender identity to use as Source
    • aws.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.
  5. 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:build then /grc-portfolio:preflight)

Step 9: Summary

Tell the user:

  • Where site-config.json and SITE-PLAN.md were created
  • Suggest they review SITE-PLAN.md and make any edits before building
  • Next command: /grc-portfolio:build to scaffold the React project
  • Full workflow: plan → build → preflight → infra → deploy → repo → cicd

Variables

  • PLUGIN_ROOT = resolved from find ~/.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 $ARGUMENTS for 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 name to the projectName from 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 pages array 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_ENDPOINT env 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 dev to preview locally
  • Suggest running /grc-portfolio:preflight next 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 from site-config.json toolkitDir field
  • $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 $ARGUMENTS for 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:repo first)
  • status.infraDeployed === true (if not, tell user to run /grc-portfolio:infra first)

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-deploy is scoped to only S3 + CloudFront for this project
  • Every push to main will 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 from site-config.json toolkitDir field
  • $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 $ARGUMENTS for 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.bucketName
  • aws.distributionId
  • aws.profile
  • aws.contactApiEndpoint (if contact form enabled)
  • aws.cloudFrontUrl
  • aws.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:

  1. If .env does not exist, create it with just this line.
  2. If .env exists and already has a VITE_CONTACT_API_ENDPOINT= line, replace only that line.
  3. If .env exists but does not contain VITE_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:repo to create a GitHub repo (if not done)
  • Suggest running /grc-portfolio:cicd to set up automatic deployments on push

Variables

  • $TOOLKIT_DIR = read from site-config.json toolkitDir field
  • $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 $ARGUMENTS for 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 name
  • aws.distributionId -- the CloudFront distribution ID
  • aws.cloudFrontUrl -- the CloudFront domain name (e.g., d123abc.cloudfront.net)

Step 7: Deploy Contact Form API (if enabled)

If features.contactForm is true:

  1. Ask the user for two SES-verified email addresses (no defaults — the stack will refuse to deploy without them):

    • SESFromEmail: verified sender identity
    • SESToEmail: 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 to aws.sesFromEmail and aws.sesToEmail in site-config.json.

  2. 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
  1. 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
  1. Save to aws.contactApiEndpoint in config.

  2. Package and deploy the Lambda function code (reference $TOOLKIT_DIR/scripts/deploy-contact-api.sh for 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:deploy next to push the built site to AWS

Variables

  • $TOOLKIT_DIR = read from site-config.json toolkitDir field
  • $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 $ARGUMENTS for 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)

  1. AWS CLI installed

    aws --version
    

    If missing: suggest running $TOOLKIT_DIR/scripts/bootstrap.sh

  2. Node.js installed (v18+)

    node --version
    
  3. npm installed

    npm --version
    
  4. AWS credentials configured

    aws sts get-caller-identity --profile <aws.profile>
    

    Record the account ID and ARN for the report.

  5. AWS region set to us-east-1 Verify aws.region in config is us-east-1 (required for CloudFront + ACM).

  6. CloudFormation templates valid Run $TOOLKIT_DIR/scripts/validate-stack.sh against the appropriate template:

    • If features.customDomain: validate $TOOLKIT_DIR/cloudformation/website-infrastructure.yaml
    • Otherwise: validate $TOOLKIT_DIR/cloudformation/website-infrastructure-no-domain.yaml

Conditional Checks

  1. SES email verified (if features.contactForm)

    aws ses get-identity-verification-attributes --identities <client.email> --profile <aws.profile> --region us-east-1
    

    Check that the status is "Success".

  2. 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.hostedZoneId in config.

  3. 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.certArn in config.

  4. 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:

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.hostedZoneId if discovered
  • Update aws.certArn if 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:build next (if not done) or /grc-portfolio:infra to deploy infrastructure

Variables

  • $TOOLKIT_DIR = read from site-config.json toolkitDir field
  • $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 $ARGUMENTS for 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 projectName from 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.repoName to the repo name
  • Set github.repoUrl to the full URL
  • Set github.owner to the owner login
  • Set github.visibility to 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:infra next (if not done) or /grc-portfolio:cicd to 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 containing site-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 containing site-config.json (optional; defaults to current directory)

What It Does

  1. Creates (or verifies) the GitHub OIDC provider in your AWS account
  2. Creates an IAM role scoped to only your S3 bucket and CloudFront distribution
  3. Generates .github/workflows/deploy.yml — triggers on push to main and workflow_dispatch
  4. Commits and pushes the workflow file
  5. Verifies the first run completes successfully

Prerequisites

  • /grc-portfolio:repo must have run (status.repoCreated === true)
  • /grc-portfolio:infra must 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:

  1. npm run build — builds the React/Vite project to dist/
  2. aws s3 sync — uploads files to your S3 bucket
  3. aws cloudfront create-invalidation — clears the CDN cache

Your live URL is printed at the end.

Arguments

  • $1 — Project directory containing site-config.json (optional; defaults to current directory)

Prerequisites

  • /grc-portfolio:build must have run (status.buildComplete === true)
  • /grc-portfolio:infra must have run (status.infraDeployed === true)

Example

/grc-portfolio:deploy ~/Desktop/repos/my-grc-portfolio
/grc-portfolio:deploy

Next Steps

  • Run /grc-portfolio:repo to push code to GitHub
  • Run /grc-portfolio:cicd to set up automatic deploys on every push to main

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 containing site-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 settings
  • SITE-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 containing site-config.json (optional; defaults to current directory)

Checks Run

  1. AWS CLI installed
  2. Node.js v18+ installed
  3. npm installed
  4. AWS credentials valid (aws sts get-caller-identity)
  5. Region set to us-east-1 (required for CloudFront + ACM)
  6. CloudFormation template valid
  7. SES email verified (if contact form enabled)
  8. Route 53 hosted zone exists (if custom domain)
  9. ACM certificate issued in us-east-1 (if custom domain)
  10. gh CLI 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 containing site-config.json (optional; defaults to current directory)

What It Does

  1. Verifies gh CLI is installed and authenticated
  2. Asks for repo name (suggests projectName from config) and visibility (public/private)
  3. Creates .gitignore if not present
  4. git init + initial commit
  5. gh 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