EGI-SOP Documentation Site Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Build a comprehensive internal documentation site for EGI using Docusaurus, migrating content from egi-engine and egi-ci:cd while applying EGI branding and updating all tool references.

Architecture: Docusaurus-based static site with 12 main documentation sections, blog for announcements, custom EGI branding (cream/navy color scheme), local search, and GitOps deployment to Vercel. Content migrated from existing repos with tool stack updates.

Tech Stack: Docusaurus v3, React, Node.js 18+, npm, Vercel, Git

File Structure

This project will create the following structure:

egi-sop/
├── package.json                                    # Dependencies and scripts
├── package-lock.json                               # Lockfile
├── docusaurus.config.js                            # Main Docusaurus config
├── sidebars.js                                     # Sidebar navigation config
├── README.md                                       # Project documentation
├── .gitignore                                      # Git ignore rules
├── static/
│   ├── img/
│   │   └── logo.svg                               # EGI logo (placeholder)
│   └── .gitkeep
├── src/
│   ├── css/
│   │   └── custom.css                             # Custom branding styles
│   ├── components/
│   │   └── .gitkeep
│   └── pages/
│       └── index.js                               # Custom homepage
├── blog/
│   ├── 2026-03-25-welcome.md                      # Initial blog post
│   └── authors.yml                                # Blog authors
├── docs/
│   ├── intro.md                                   # Site introduction
│   ├── company-operations/
│   │   ├── index.md
│   │   ├── communication-standards.md
│   │   ├── slack-conventions.md
│   │   ├── ownership-model.md
│   │   ├── documentation-standards.md
│   │   └── workflow-rules.md
│   ├── engineering-standards/
│   │   ├── index.md
│   │   ├── repo-conventions.md                   # From egi-ci:cd
│   │   ├── development-workflow.md
│   │   ├── approval-gates.md
│   │   ├── release-procedures.md
│   │   ├── rollback-procedures.md
│   │   ├── documentation-requirements.md
│   │   ├── ai-assisted-development.md
│   │   ├── architecture.md                       # From egi-ci:cd
│   │   ├── decisions/                            # ADRs from egi-ci:cd
│   │   ├── ci-cd/                                # From egi-ci:cd
│   │   └── integrations/                         # From egi-engine
│   ├── product-operations/
│   │   ├── index.md
│   │   ├── product-lifecycle.md
│   │   ├── launch-checklist.md
│   │   ├── release-checklist.md
│   │   ├── analytics-instrumentation.md
│   │   ├── feature-flags.md
│   │   └── support-ownership.md
│   ├── client-delivery/
│   │   ├── index.md
│   │   ├── onboarding-workflow.md
│   │   ├── documentation-expectations.md
│   │   ├── handoff-procedures.md
│   │   ├── deployment-standards.md
│   │   ├── ownership-model.md
│   │   └── support-model.md
│   ├── sku-standards/
│   │   ├── index.md                              # From egi-engine
│   │   ├── naming-conventions.md
│   │   ├── platform-identifiers.md
│   │   ├── system-types.md
│   │   ├── release-conventions.md
│   │   ├── examples.md
│   │   ├── tooling.md
│   │   └── update-process.md
│   ├── pricing-standards/
│   │   ├── index.md
│   │   ├── pricing-methodology.md
│   │   ├── estimation-standards.md
│   │   ├── packaging-rules.md
│   │   ├── stripe-integration.md
│   │   ├── calculator-reference.md
│   │   └── pricing-tiers.md
│   ├── tooling-stack/
│   │   ├── index.md
│   │   ├── slack.md
│   │   ├── erpnext.md
│   │   ├── posthog.md
│   │   ├── cloudflare.md
│   │   ├── uptime-kuma.md
│   │   ├── crowdsec.md
│   │   ├── docusaurus.md
│   │   ├── vercel.md
│   │   ├── penpot.md
│   │   └── stripe.md
│   ├── auth-access/
│   │   ├── index.md
│   │   ├── auth-patterns.md
│   │   ├── access-expectations.md
│   │   ├── documenting-auth.md
│   │   ├── account-provisioning.md
│   │   └── future-planning.md
│   ├── monitoring-incident/
│   │   ├── index.md
│   │   ├── monitoring-standards.md
│   │   ├── health-checks.md
│   │   ├── alert-routing.md
│   │   ├── outage-response.md
│   │   ├── degraded-service.md
│   │   ├── rollback-procedures.md
│   │   ├── incident-response.md
│   │   ├── postmortem-template.md
│   │   └── runbooks/                             # From egi-engine
│   ├── onboarding-offboarding/
│   │   ├── index.md
│   │   ├── employee-setup.md
│   │   ├── account-access.md
│   │   ├── tools-required.md
│   │   ├── documentation-expectations.md
│   │   └── offboarding-procedures.md
│   ├── migration-archival/
│   │   ├── index.md
│   │   ├── system-migration.md
│   │   ├── domain-cutover.md
│   │   ├── backup-verification.md
│   │   ├── rollback-planning.md
│   │   ├── legacy-labeling.md
│   │   └── archival-procedures.md
│   └── reference-library/
│       ├── index.md
│       ├── glossary.md
│       ├── naming-conventions.md
│       ├── metadata-schema.md
│       ├── links.md
│       ├── templates/
│       │   ├── sop-template.md
│       │   ├── system-profile-template.md
│       │   ├── execution-brief-template.md
│       │   ├── incident-report-template.md
│       │   ├── migration-checklist.md
│       │   ├── domain-cutover-checklist.md
│       │   ├── repo-audit-checklist.md
│       │   ├── product-launch-checklist.md
│       │   ├── client-onboarding-checklist.md
│       │   └── uptime-monitoring-checklist.md
│       └── checklists/
│           └── .gitkeep

Phase 1: Project Initialization

Task 1: Initialize Docusaurus Project

Files:

Create: package.json
Create: docusaurus.config.js
Create: sidebars.js
Create: .gitignore
Step 1: Initialize Docusaurus using npx

Run: npx create-docusaurus@latest . classic --typescript false

Expected: Docusaurus project created with default structure

Note: Run this in the /Users/elliottgodwin/Developer/egi-sop directory

Step 2: Verify installation

Run: npm run start

Expected: Dev server starts at http://localhost:3000 with default Docusaurus site

Step 3: Stop dev server

Press: Ctrl+C

Expected: Server stops

Step 4: Remove default content

Run:

rm -rf blog/* docs/*
mkdir -p blog docs

Expected: Default blog and docs content removed

Step 5: Commit initial setup

git add .
git commit -m "chore: initialize Docusaurus project

- Install Docusaurus v3 with classic preset
- Remove default content
- Prepare for custom structure

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 2: Configure Docusaurus for EGI

Files:

Modify: docusaurus.config.js
Step 1: Update docusaurus.config.js with EGI configuration

// @ts-check
// Note: type annotations allow type checking and IDEs autocompletion

const lightCodeTheme = require('prism-react-renderer/themes/github');
const darkCodeTheme = require('prism-react-renderer/themes/dracula');

/** @type {import('@docusaurus/types').Config} */
const config = {
  title: 'EGI SOP',
  tagline: 'Internal Standards & Operations Library',
  favicon: 'img/favicon.ico',

  url: 'https://sop.egintegrations.com',
  baseUrl: '/',

  organizationName: 'egintegrations',
  projectName: 'egi-sop',

  onBrokenLinks: 'throw',
  onBrokenMarkdownLinks: 'warn',

  i18n: {
    defaultLocale: 'en',
    locales: ['en'],
  },

  presets: [
    [
      'classic',
      /** @type {import('@docusaurus/preset-classic').Options} */
      ({
        docs: {
          sidebarPath: require.resolve('./sidebars.js'),
          editUrl: undefined, // Remove edit links for internal docs
        },
        blog: {
          showReadingTime: true,
          blogTitle: 'SOP Changelog',
          blogDescription: 'Updates and announcements for EGI standard operating procedures',
          postsPerPage: 10,
          blogSidebarTitle: 'Recent updates',
          blogSidebarCount: 'ALL',
        },
        theme: {
          customCss: require.resolve('./src/css/custom.css'),
        },
      }),
    ],
  ],

  themeConfig:
    /** @type {import('@docusaurus/preset-classic').ThemeConfig} */
    ({
      image: 'img/social-card.png',
      navbar: {
        title: 'EGI SOP',
        logo: {
          alt: 'EGI Logo',
          src: 'img/logo.svg',
        },
        items: [
          {
            type: 'docSidebar',
            sidebarId: 'docsSidebar',
            position: 'left',
            label: 'Documentation',
          },
          {to: '/blog', label: 'Changelog', position: 'left'},
        ],
      },
      footer: {
        style: 'dark',
        links: [
          {
            title: 'Documentation',
            items: [
              {
                label: 'Company Operations',
                to: '/docs/company-operations',
              },
              {
                label: 'Engineering Standards',
                to: '/docs/engineering-standards',
              },
              {
                label: 'Tooling Stack',
                to: '/docs/tooling-stack',
              },
            ],
          },
          {
            title: 'Resources',
            items: [
              {
                label: 'Templates',
                to: '/docs/reference-library/templates',
              },
              {
                label: 'Glossary',
                to: '/docs/reference-library/glossary',
              },
              {
                label: 'Changelog',
                to: '/blog',
              },
            ],
          },
        ],
        copyright: `Copyright © ${new Date().getFullYear()} EGIntegrations. Internal use only.`,
      },
      prism: {
        theme: lightCodeTheme,
        darkTheme: darkCodeTheme,
        additionalLanguages: ['bash', 'python', 'javascript', 'typescript', 'yaml', 'json'],
      },
    }),

  plugins: [
    [
      require.resolve("@cmfcmf/docusaurus-search-local"),
      {
        indexDocs: true,
        indexBlog: true,
        indexPages: false,
        language: "en",
      },
    ],
  ],
};

module.exports = config;

Step 2: Install local search plugin

Run: npm install --save @cmfcmf/docusaurus-search-local

Expected: Search plugin installed successfully

Step 3: Verify configuration

Run: npm run build

Expected: Build completes without errors

Step 4: Commit configuration

git add docusaurus.config.js package.json package-lock.json
git commit -m "feat: configure Docusaurus for EGI

- Set site title, URL, and metadata
- Configure navbar and footer
- Add local search plugin
- Set up blog for changelog
- Disable edit links for internal docs

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Files:

Modify: sidebars.js
Step 1: Create comprehensive sidebar structure

/**
 * Creating a sidebar enables you to:
 - create an ordered group of docs
 - render a sidebar for each doc of that group
 - provide next/previous navigation

 The sidebars can be generated from the filesystem, or explicitly defined here.

 Create as many sidebars as you want.
 */

// @ts-check

/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
const sidebars = {
  docsSidebar: [
    'intro',
    {
      type: 'category',
      label: 'Company Operations',
      link: {
        type: 'doc',
        id: 'company-operations/index',
      },
      collapsed: false,
      items: [
        'company-operations/communication-standards',
        'company-operations/slack-conventions',
        'company-operations/ownership-model',
        'company-operations/documentation-standards',
        'company-operations/workflow-rules',
      ],
    },
    {
      type: 'category',
      label: 'Engineering Standards',
      link: {
        type: 'doc',
        id: 'engineering-standards/index',
      },
      collapsed: false,
      items: [
        'engineering-standards/repo-conventions',
        'engineering-standards/development-workflow',
        'engineering-standards/approval-gates',
        'engineering-standards/release-procedures',
        'engineering-standards/rollback-procedures',
        'engineering-standards/documentation-requirements',
        'engineering-standards/ai-assisted-development',
        'engineering-standards/architecture',
        {
          type: 'category',
          label: 'Architecture Decisions',
          link: {
            type: 'generated-index',
            title: 'Architecture Decision Records',
            description: 'Historical architecture decisions and their context.',
          },
          items: [
            {
              type: 'autogenerated',
              dirName: 'engineering-standards/decisions',
            },
          ],
        },
        {
          type: 'category',
          label: 'CI/CD',
          link: {
            type: 'generated-index',
            title: 'CI/CD Documentation',
            description: 'Golden path for continuous integration and deployment.',
          },
          items: [
            {
              type: 'autogenerated',
              dirName: 'engineering-standards/ci-cd',
            },
          ],
        },
        {
          type: 'category',
          label: 'Integrations',
          link: {
            type: 'generated-index',
            title: 'Integration Patterns',
            description: 'Provider adapters and integration documentation.',
          },
          items: [
            {
              type: 'autogenerated',
              dirName: 'engineering-standards/integrations',
            },
          ],
        },
      ],
    },
    {
      type: 'category',
      label: 'Product Operations',
      link: {
        type: 'doc',
        id: 'product-operations/index',
      },
      collapsed: true,
      items: [
        'product-operations/product-lifecycle',
        'product-operations/launch-checklist',
        'product-operations/release-checklist',
        'product-operations/analytics-instrumentation',
        'product-operations/feature-flags',
        'product-operations/support-ownership',
      ],
    },
    {
      type: 'category',
      label: 'Client Delivery',
      link: {
        type: 'doc',
        id: 'client-delivery/index',
      },
      collapsed: true,
      items: [
        'client-delivery/onboarding-workflow',
        'client-delivery/documentation-expectations',
        'client-delivery/handoff-procedures',
        'client-delivery/deployment-standards',
        'client-delivery/ownership-model',
        'client-delivery/support-model',
      ],
    },
    {
      type: 'category',
      label: 'SKU Standards',
      link: {
        type: 'doc',
        id: 'sku-standards/index',
      },
      collapsed: true,
      items: [
        'sku-standards/naming-conventions',
        'sku-standards/platform-identifiers',
        'sku-standards/system-types',
        'sku-standards/release-conventions',
        'sku-standards/examples',
        'sku-standards/tooling',
        'sku-standards/update-process',
      ],
    },
    {
      type: 'category',
      label: 'Pricing Standards',
      link: {
        type: 'doc',
        id: 'pricing-standards/index',
      },
      collapsed: true,
      items: [
        'pricing-standards/pricing-methodology',
        'pricing-standards/estimation-standards',
        'pricing-standards/packaging-rules',
        'pricing-standards/stripe-integration',
        'pricing-standards/calculator-reference',
        'pricing-standards/pricing-tiers',
      ],
    },
    {
      type: 'category',
      label: 'Tooling Stack',
      link: {
        type: 'doc',
        id: 'tooling-stack/index',
      },
      collapsed: true,
      items: [
        'tooling-stack/slack',
        'tooling-stack/erpnext',
        'tooling-stack/posthog',
        'tooling-stack/cloudflare',
        'tooling-stack/uptime-kuma',
        'tooling-stack/crowdsec',
        'tooling-stack/docusaurus',
        'tooling-stack/vercel',
        'tooling-stack/penpot',
        'tooling-stack/stripe',
      ],
    },
    {
      type: 'category',
      label: 'Auth & Access',
      link: {
        type: 'doc',
        id: 'auth-access/index',
      },
      collapsed: true,
      items: [
        'auth-access/auth-patterns',
        'auth-access/access-expectations',
        'auth-access/documenting-auth',
        'auth-access/account-provisioning',
        'auth-access/future-planning',
      ],
    },
    {
      type: 'category',
      label: 'Monitoring & Incident Response',
      link: {
        type: 'doc',
        id: 'monitoring-incident/index',
      },
      collapsed: true,
      items: [
        'monitoring-incident/monitoring-standards',
        'monitoring-incident/health-checks',
        'monitoring-incident/alert-routing',
        'monitoring-incident/outage-response',
        'monitoring-incident/degraded-service',
        'monitoring-incident/rollback-procedures',
        'monitoring-incident/incident-response',
        'monitoring-incident/postmortem-template',
        {
          type: 'category',
          label: 'Runbooks',
          link: {
            type: 'generated-index',
            title: 'Operational Runbooks',
            description: 'Step-by-step operational procedures.',
          },
          items: [
            {
              type: 'autogenerated',
              dirName: 'monitoring-incident/runbooks',
            },
          ],
        },
      ],
    },
    {
      type: 'category',
      label: 'Onboarding & Offboarding',
      link: {
        type: 'doc',
        id: 'onboarding-offboarding/index',
      },
      collapsed: true,
      items: [
        'onboarding-offboarding/employee-setup',
        'onboarding-offboarding/account-access',
        'onboarding-offboarding/tools-required',
        'onboarding-offboarding/documentation-expectations',
        'onboarding-offboarding/offboarding-procedures',
      ],
    },
    {
      type: 'category',
      label: 'Migration & Archival',
      link: {
        type: 'doc',
        id: 'migration-archival/index',
      },
      collapsed: true,
      items: [
        'migration-archival/system-migration',
        'migration-archival/domain-cutover',
        'migration-archival/backup-verification',
        'migration-archival/rollback-planning',
        'migration-archival/legacy-labeling',
        'migration-archival/archival-procedures',
      ],
    },
    {
      type: 'category',
      label: 'Reference Library',
      link: {
        type: 'doc',
        id: 'reference-library/index',
      },
      collapsed: true,
      items: [
        'reference-library/glossary',
        'reference-library/naming-conventions',
        'reference-library/metadata-schema',
        'reference-library/links',
        {
          type: 'category',
          label: 'Templates',
          link: {
            type: 'generated-index',
            title: 'Document Templates',
            description: 'Reusable templates for SOPs, reports, and checklists.',
          },
          items: [
            {
              type: 'autogenerated',
              dirName: 'reference-library/templates',
            },
          ],
        },
      ],
    },
  ],
};

module.exports = sidebars;

Step 2: Verify sidebar configuration

Run: npm run build

Expected: Build succeeds (will warn about missing docs, expected at this stage)

Step 3: Commit sidebar configuration

git add sidebars.js
git commit -m "feat: configure comprehensive sidebar navigation

- 12 main documentation sections
- Collapsible categories
- Auto-generated sections for ADRs, CI/CD, integrations, runbooks
- Reference library with templates

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 2: Branding & Custom Styling

Task 4: Apply EGI Branding

Files:

Modify: src/css/custom.css
Create: static/img/logo.svg (placeholder)
Step 1: Create custom CSS with EGI brand colors

/**
 * EGI SOP Custom Styles
 *
 * Brand Colors:
 * - Primary: #F5F1E8 (cream/beige)
 * - Secondary: #1A1D23 (dark navy/charcoal)
 * - Accent: #0096D6 (blue)
 */

:root {
  /* Brand Colors */
  --egi-cream: #F5F1E8;
  --egi-navy: #1A1D23;
  --egi-blue: #0096D6;
  --egi-orange: #FF6B35;

  /* Light Mode */
  --ifm-color-primary: #0096D6;
  --ifm-color-primary-dark: #0085C1;
  --ifm-color-primary-darker: #007DB5;
  --ifm-color-primary-darkest: #006795;
  --ifm-color-primary-light: #00A7EB;
  --ifm-color-primary-lighter: #00AFF7;
  --ifm-color-primary-lightest: #1FC3FF;

  --ifm-background-color: #F5F1E8;
  --ifm-background-surface-color: #FFFFFF;

  --ifm-font-color-base: #1A1D23;
  --ifm-heading-color: #1A1D23;

  --ifm-link-color: #0096D6;
  --ifm-link-hover-color: #007DB5;

  --ifm-navbar-background-color: #1A1D23;
  --ifm-navbar-link-color: #F5F1E8;
  --ifm-navbar-link-hover-color: #0096D6;

  --ifm-footer-background-color: #1A1D23;
  --ifm-footer-color: #F5F1E8;
  --ifm-footer-link-color: #0096D6;
  --ifm-footer-link-hover-color: #00A7EB;

  /* Card styling */
  --ifm-card-background-color: #FFFFFF;
  --ifm-card-border-radius: 8px;

  /* Code blocks */
  --ifm-code-background: #F5F5F5;
  --ifm-code-border-radius: 4px;

  /* Fonts */
  --ifm-font-family-base: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
  --ifm-font-family-monospace: 'Fira Code', 'Monaco', 'Consolas', 'Liberation Mono', 'Courier New', monospace;
  --ifm-heading-font-weight: 700;
}

/* Dark mode */
[data-theme='dark'] {
  --ifm-color-primary: #0096D6;
  --ifm-color-primary-dark: #0085C1;
  --ifm-color-primary-darker: #007DB5;
  --ifm-color-primary-darkest: #006795;
  --ifm-color-primary-light: #00A7EB;
  --ifm-color-primary-lighter: #00AFF7;
  --ifm-color-primary-lightest: #1FC3FF;

  --ifm-background-color: #1A1D23;
  --ifm-background-surface-color: #242830;

  --ifm-font-color-base: #F5F1E8;
  --ifm-heading-color: #F5F1E8;

  --ifm-link-color: #00A7EB;
  --ifm-link-hover-color: #1FC3FF;

  --ifm-navbar-background-color: #1A1D23;
  --ifm-navbar-link-color: #F5F1E8;
  --ifm-navbar-link-hover-color: #00A7EB;

  --ifm-card-background-color: #242830;

  --ifm-code-background: #2D3139;
}

/* Typography improvements */
h1, h2, h3, h4, h5, h6 {
  font-weight: var(--ifm-heading-font-weight);
  margin-bottom: 1rem;
}

/* Card enhancements */
.card {
  border-radius: var(--ifm-card-border-radius);
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
  transition: box-shadow 0.3s ease;
}

.card:hover {
  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.15);
}

/* Button styling */
.button {
  border-radius: 6px;
  font-weight: 600;
  transition: all 0.2s ease;
}

.button:hover {
  transform: translateY(-1px);
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
}

.button--primary {
  background-color: var(--ifm-color-primary);
  border-color: var(--ifm-color-primary);
}

.button--primary:hover {
  background-color: var(--ifm-color-primary-dark);
  border-color: var(--ifm-color-primary-dark);
}

/* Admonition customization */
.admonition {
  border-radius: 6px;
  margin-bottom: 1.5rem;
}

/* Code block improvements */
.prism-code {
  border-radius: var(--ifm-code-border-radius);
}

/* Table of contents */
.table-of-contents {
  font-size: 0.875rem;
}

.table-of-contents__link {
  color: var(--ifm-font-color-base);
}

.table-of-contents__link:hover,
.table-of-contents__link--active {
  color: var(--ifm-color-primary);
  font-weight: 600;
}

/* Navbar customization */
.navbar {
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.navbar__title {
  font-weight: 700;
}

/* Footer customization */
.footer {
  padding: 2rem 0;
}

.footer__title {
  font-weight: 700;
  color: #F5F1E8;
}

/* Pagination */
.pagination-nav__link {
  border-radius: 6px;
  border: 1px solid var(--ifm-color-emphasis-300);
}

.pagination-nav__link:hover {
  border-color: var(--ifm-color-primary);
  background-color: var(--ifm-color-primary-lightest);
}

/* Breadcrumbs */
.breadcrumbs__link {
  color: var(--ifm-color-emphasis-600);
}

.breadcrumbs__link:hover {
  color: var(--ifm-color-primary);
}

/* Search bar */
.DocSearch-Button {
  border-radius: 6px;
}

/* Responsive adjustments */
@media (max-width: 996px) {
  .navbar__item {
    font-size: 0.9rem;
  }
}

Step 2: Create placeholder logo

<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
  <circle cx="20" cy="20" r="18" fill="#0096D6"/>
  <text x="50%" y="50%" text-anchor="middle" dy=".3em" fill="#F5F1E8" font-family="Arial, sans-serif" font-size="20" font-weight="bold">EGI</text>
</svg>

Save to: static/img/logo.svg

Step 3: Import Google Fonts in custom.css

Add to top of src/css/custom.css:

/* Import Google Fonts */
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');

Step 4: Test branding

Run: npm run start

Expected: Site loads with EGI cream background, navy navbar, blue accents

Step 5: Commit branding

git add src/css/custom.css static/img/logo.svg
git commit -m "feat: apply EGI branding and custom styles

- Cream (#F5F1E8) and navy (#1A1D23) color scheme
- Blue (#0096D6) accent color
- Inter font family for headings and body
- Custom card, button, and admonition styling
- Dark mode support with inverted colors
- Placeholder EGI logo

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 5: Create Custom Homepage

Files:

Create: src/pages/index.js
Step 1: Create React homepage component

import React from 'react';
import clsx from 'clsx';
import Link from '@docusaurus/Link';
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import Layout from '@theme/Layout';
import styles from './index.module.css';

function HomepageHeader() {
  const {siteConfig} = useDocusaurusContext();
  return (
    <header className={clsx('hero hero--primary', styles.heroBanner)}>
      <div className="container">
        <h1 className="hero__title">{siteConfig.title}</h1>
        <p className="hero__subtitle">{siteConfig.tagline}</p>
        <div className={styles.buttons}>
          <Link
            className="button button--secondary button--lg"
            to="/docs/intro">
            Get Started
          </Link>
          <Link
            className="button button--outline button--secondary button--lg"
            to="/docs/tooling-stack">
            Tooling Stack
          </Link>
        </div>
      </div>
    </header>
  );
}

function FeatureSection() {
  const features = [
    {
      title: 'Company Operations',
      icon: '🏢',
      description: 'Internal communication, ownership models, and workflow standards.',
      link: '/docs/company-operations',
    },
    {
      title: 'Engineering Standards',
      icon: '⚙️',
      description: 'Development workflows, CI/CD, architecture decisions, and release procedures.',
      link: '/docs/engineering-standards',
    },
    {
      title: 'Product Operations',
      icon: '🚀',
      description: 'Product lifecycle, launch checklists, analytics, and feature flag management.',
      link: '/docs/product-operations',
    },
    {
      title: 'Client Delivery',
      icon: '🤝',
      description: 'Onboarding workflows, handoff procedures, and support models.',
      link: '/docs/client-delivery',
    },
    {
      title: 'SKU Standards',
      icon: '🏷️',
      description: 'Standardized SKU format, naming conventions, and versioning.',
      link: '/docs/sku-standards',
    },
    {
      title: 'Pricing Standards',
      icon: '💰',
      description: 'Pricing methodology, estimation standards, and Stripe integration.',
      link: '/docs/pricing-standards',
    },
    {
      title: 'Tooling Stack',
      icon: '🛠️',
      description: 'Documentation for Slack, ERPNext, PostHog, Cloudflare, and more.',
      link: '/docs/tooling-stack',
    },
    {
      title: 'Monitoring & Incidents',
      icon: '📊',
      description: 'Uptime monitoring, incident response, and operational runbooks.',
      link: '/docs/monitoring-incident',
    },
    {
      title: 'Reference Library',
      icon: '📚',
      description: 'Templates, checklists, glossary, and quick references.',
      link: '/docs/reference-library',
    },
  ];

  return (
    <section className={styles.features}>
      <div className="container">
        <h2 className={styles.sectionTitle}>Documentation Sections</h2>
        <div className={styles.featureGrid}>
          {features.map((feature, idx) => (
            <Link
              key={idx}
              to={feature.link}
              className={clsx('card', styles.featureCard)}>
              <div className={styles.featureIcon}>{feature.icon}</div>
              <h3>{feature.title}</h3>
              <p>{feature.description}</p>
            </Link>
          ))}
        </div>
      </div>
    </section>
  );
}

function QuickLinks() {
  return (
    <section className={styles.quickLinks}>
      <div className="container">
        <h2 className={styles.sectionTitle}>Quick Links</h2>
        <div className={styles.linkGrid}>
          <Link to="/docs/reference-library/templates" className="card">
            <h3>📝 Templates</h3>
            <p>SOP templates, checklists, and execution briefs</p>
          </Link>
          <Link to="/blog" className="card">
            <h3>📰 Changelog</h3>
            <p>Latest updates and announcements</p>
          </Link>
          <Link to="/docs/reference-library/glossary" className="card">
            <h3>📖 Glossary</h3>
            <p>Company terminology and definitions</p>
          </Link>
          <Link to="/docs/tooling-stack" className="card">
            <h3>🔧 Tools</h3>
            <p>Complete tooling stack documentation</p>
          </Link>
        </div>
      </div>
    </section>
  );
}

export default function Home() {
  const {siteConfig} = useDocusaurusContext();
  return (
    <Layout
      title={`${siteConfig.title}`}
      description="EGI Internal Standards and Operations Library">
      <HomepageHeader />
      <main>
        <FeatureSection />
        <QuickLinks />
      </main>
    </Layout>
  );
}

Step 2: Create CSS module for homepage

Create: src/pages/index.module.css

.heroBanner {
  padding: 4rem 0;
  text-align: center;
  position: relative;
  overflow: hidden;
  background: linear-gradient(135deg, var(--egi-navy) 0%, #2A2F38 100%);
}

.heroBanner h1 {
  font-size: 3rem;
  color: var(--egi-cream);
  margin-bottom: 1rem;
}

.heroBanner p {
  font-size: 1.5rem;
  color: var(--egi-cream);
  margin-bottom: 2rem;
}

.buttons {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 1rem;
  flex-wrap: wrap;
}

.features {
  padding: 4rem 0;
  background-color: var(--ifm-background-color);
}

.sectionTitle {
  text-align: center;
  font-size: 2.5rem;
  margin-bottom: 3rem;
  color: var(--ifm-heading-color);
}

.featureGrid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
  gap: 2rem;
  margin-top: 2rem;
}

.featureCard {
  text-decoration: none;
  color: inherit;
  padding: 2rem;
  transition: transform 0.2s ease, box-shadow 0.2s ease;
}

.featureCard:hover {
  transform: translateY(-4px);
  text-decoration: none;
  color: inherit;
}

.featureIcon {
  font-size: 3rem;
  margin-bottom: 1rem;
}

.featureCard h3 {
  margin-bottom: 0.5rem;
  color: var(--ifm-heading-color);
}

.featureCard p {
  font-size: 0.95rem;
  color: var(--ifm-color-emphasis-700);
  margin: 0;
}

.quickLinks {
  padding: 4rem 0;
  background-color: var(--ifm-background-surface-color);
}

.linkGrid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
  gap: 1.5rem;
  margin-top: 2rem;
}

.linkGrid .card {
  padding: 1.5rem;
  text-decoration: none;
  color: inherit;
  transition: transform 0.2s ease, box-shadow 0.2s ease;
}

.linkGrid .card:hover {
  transform: translateY(-2px);
  text-decoration: none;
  color: inherit;
}

.linkGrid h3 {
  font-size: 1.25rem;
  margin-bottom: 0.5rem;
  color: var(--ifm-heading-color);
}

.linkGrid p {
  font-size: 0.9rem;
  color: var(--ifm-color-emphasis-700);
  margin: 0;
}

@media (max-width: 768px) {
  .heroBanner h1 {
    font-size: 2rem;
  }

  .heroBanner p {
    font-size: 1.2rem;
  }

  .featureGrid {
    grid-template-columns: 1fr;
  }

  .linkGrid {
    grid-template-columns: 1fr;
  }
}

Step 3: Test homepage

Run: npm run start

Expected: Homepage displays with hero banner, feature grid, and quick links

Step 4: Commit homepage

git add src/pages/
git commit -m "feat: create custom EGI homepage

- Hero banner with navy gradient background
- Feature grid showing all 12 documentation sections
- Quick links section for common resources
- Responsive grid layout
- Card-based design matching EGI branding

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 3: Core Documentation Structure

Task 6: Create Introduction and Core Index Pages

Files:

Create: docs/intro.md
Create: docs/company-operations/index.md
Create: docs/engineering-standards/index.md
Create: docs/product-operations/index.md
Create: docs/client-delivery/index.md
Create: docs/sku-standards/index.md
Create: docs/pricing-standards/index.md
Create: docs/tooling-stack/index.md
Create: docs/auth-access/index.md
Create: docs/monitoring-incident/index.md
Create: docs/onboarding-offboarding/index.md
Create: docs/migration-archival/index.md
Create: docs/reference-library/index.md
Step 1: Create site introduction

docs/intro.md:

---
title: Welcome to EGI SOP
description: Internal standards and operations library for EGIntegrations
sidebar_position: 1
last_updated: 2026-03-25
---

# Welcome to EGI SOP

Welcome to the EGIntegrations Standard Operating Procedures and Internal Documentation Library. This site serves as the central source of truth for company operations, engineering standards, client delivery processes, and operational workflows.

## Purpose

EGI-SOP consolidates our scattered documentation into a single, well-organized, maintainable system that:

- **Centralizes Knowledge**: All company standards, procedures, and documentation in one place
- **Ensures Consistency**: Standardized formats and templates across all documentation
- **Enables Collaboration**: Easy contribution through GitOps workflow
- **Maintains History**: Version-controlled documentation with full change history
- **Supports Growth**: Scalable structure designed for long-term evolution

## Documentation Sections

### [Company Operations](/docs/company-operations)
Internal communication standards, Slack conventions, ownership models, and workflow rules.

### [Engineering Standards](/docs/engineering-standards)
Development workflows, CI/CD golden path, architecture decisions, and release procedures.

### [Product Operations](/docs/product-operations)
Product lifecycle management, launch checklists, analytics instrumentation, and feature flags.

### [Client Delivery](/docs/client-delivery)
Client onboarding workflows, handoff procedures, deployment standards, and support models.

### [SKU Standards](/docs/sku-standards)
Standardized SKU format, naming conventions, platform identifiers, and versioning rules.

### [Pricing Standards](/docs/pricing-standards)
Pricing methodology, estimation standards, packaging rules, and Stripe integration.

### [Tooling Stack](/docs/tooling-stack)
Complete documentation for all tools in the EGI stack: Slack, ERPNext, PostHog, Cloudflare, Uptime Kuma, CrowdSec, and more.

### [Auth & Access](/docs/auth-access)
Authentication patterns, access policies, account provisioning, and future consolidation plans.

### [Monitoring & Incident Response](/docs/monitoring-incident)
Monitoring standards, incident response procedures, operational runbooks, and postmortem templates.

### [Onboarding & Offboarding](/docs/onboarding-offboarding)
Employee lifecycle procedures, account provisioning, tool access, and handoff workflows.

### [Migration & Archival](/docs/migration-archival)
System migration procedures, domain cutover processes, backup verification, and archival standards.

### [Reference Library](/docs/reference-library)
Templates, checklists, glossary, naming conventions, and quick reference materials.

## Our Tooling Stack

EGI uses a consolidated tooling stack for maximum efficiency:

- **Slack** - Internal communication and collaboration
- **ERPNext** - ERP and business process management
- **PostHog** - Product analytics and instrumentation
- **Cloudflare** - DNS, security, and CDN
- **Uptime Kuma** - Uptime monitoring and alerting
- **CrowdSec** - Intrusion detection for cloud instances
- **Docusaurus** - This documentation system
- **Vercel** - Deployment and hosting
- **Penpot** - Design and prototyping
- **Stripe** - Payment processing

[Learn more about our tooling stack →](/docs/tooling-stack)

## Contributing

This documentation follows a GitOps workflow. All changes go through pull requests and are reviewed before merging.

**Quick Start:**
1. Clone the repository
2. Create a feature branch
3. Make your changes
4. Test locally with `npm run start`
5. Open a pull request
6. Team reviews and merges

See the [README](https://github.com/egintegrations/egi-sop) for detailed contribution guidelines.

## Getting Help

- **Slack**: #egi-sop for questions and discussions
- **GitHub Issues**: Report documentation bugs or request improvements
- **Templates**: Use our [templates](/docs/reference-library/templates) for creating new docs

## Recent Updates

Check the [Changelog](/blog) for recent updates and announcements.

---

*This documentation is for internal EGIntegrations use only.*

Step 2: Create company operations index

Create directory and file:

mkdir -p docs/company-operations

docs/company-operations/index.md:

---
title: Company Operations
description: Internal company operation standards and expectations
sidebar_position: 1
last_updated: 2026-03-25
---

# Company Operations

Company Operations defines how we work together as a team, communicate effectively, maintain ownership and accountability, and document our work. These standards ensure consistency, clarity, and efficiency across all internal operations.

## Overview

Our operational philosophy centers on:

- **Clear Communication**: Transparent, timely, and structured communication
- **Defined Ownership**: Every system, project, and process has a clear owner
- **Documentation First**: If it's not documented, it doesn't exist
- **Continuous Improvement**: Regular review and refinement of processes
- **Team Collaboration**: Leverage collective knowledge while maintaining individual accountability

## Key Principles

### Transparency
All team members have access to the information they need to do their jobs effectively. We default to open communication and only restrict access when necessary for security or privacy.

### Ownership
Every deliverable, system, and process has a designated owner responsible for its success, maintenance, and evolution.

### Documentation
We document decisions, processes, and systems to enable:
- Knowledge transfer
- Onboarding efficiency
- Process consistency
- Historical context
- Team scalability

### Asynchronous by Default
We prioritize asynchronous communication to:
- Respect different time zones and work schedules
- Enable thoughtful, well-documented responses
- Create searchable records of decisions
- Reduce meeting overhead

## Section Contents

### [Communication Standards](/docs/company-operations/communication-standards)
Expectations for internal communication, response times, escalation paths, and communication channels.

### [Slack Conventions](/docs/company-operations/slack-conventions)
Channel naming, threading rules, notification etiquette, and Slack best practices.

### [Ownership Model](/docs/company-operations/ownership-model)
How we define, assign, and manage ownership of projects, systems, and deliverables.

### [Documentation Standards](/docs/company-operations/documentation-standards)
Requirements and best practices for creating and maintaining documentation.

### [Workflow Rules](/docs/company-operations/workflow-rules)
Internal workflow standards, approval processes, and collaboration patterns.

## Related Documentation

- [Engineering Standards](/docs/engineering-standards) - Technical workflow standards
- [Tooling Stack](/docs/tooling-stack) - Documentation for communication tools
- [Onboarding & Offboarding](/docs/onboarding-offboarding) - Employee lifecycle procedures

## Changelog

- **2026-03-25**: Initial company operations documentation created

Step 3: Create remaining index files with similar structure

Due to space constraints, I'll provide the template structure. Each index should follow this pattern:

---
title: [Section Name]
description: [Brief description]
sidebar_position: [number]
last_updated: 2026-03-25
---

# [Section Name]

[2-3 paragraph overview of the section]

## Overview

[Key principles and philosophy]

## Section Contents

[List of pages in this section with brief descriptions]

## Related Documentation

[Links to related sections]

## Changelog

- **2026-03-25**: Initial [section name] documentation created

Create these files:

docs/engineering-standards/index.md
docs/product-operations/index.md
docs/client-delivery/index.md
docs/sku-standards/index.md
docs/pricing-standards/index.md
docs/tooling-stack/index.md
docs/auth-access/index.md
docs/monitoring-incident/index.md
docs/onboarding-offboarding/index.md
docs/migration-archival/index.md
docs/reference-library/index.md
Step 4: Verify build

Run: npm run build

Expected: Build succeeds with all index pages

Step 5: Commit core structure

git add docs/
git commit -m "feat: create core documentation structure

- Site introduction with overview and quick links
- Index pages for all 12 main sections
- Consistent frontmatter and structure
- Section overviews and content descriptions

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Note: Due to the extensive nature of this implementation plan, I'll continue with abbreviated task descriptions for the remaining phases. Each task will follow the same detailed format with complete code blocks, verification steps, and commits.

Phase 4: Content Migration from egi-engine

Task 7: Migrate SKU Standards Documentation

Files:

Create: docs/sku-standards/naming-conventions.md
Create: docs/sku-standards/platform-identifiers.md
Create: docs/sku-standards/system-types.md
Create: docs/sku-standards/release-conventions.md
Create: docs/sku-standards/examples.md
Create: docs/sku-standards/tooling.md
Create: docs/sku-standards/update-process.md
Step 1: Migrate and update SKU standards index

Update docs/sku-standards/index.md with content from ~/Developer/egi-engine/standards/sku/README.md, updating tool references

Step 2: Create SKU naming conventions page

Extract format, components, and best practices into naming-conventions.md

Step 3: Create platform identifiers page

Extract platform codes table and add link to egi-engine repo for platforms.json

Step 4: Create system types page

Extract system type codes and add link to egi-engine repo for system_types.json

Step 5: Create remaining SKU pages

Create release-conventions.md, examples.md, tooling.md (with links to gen_sku.py and sku_audit.py), and update-process.md

Step 6: Verify SKU section

Run: npm run start and navigate to SKU Standards section

Expected: All pages render correctly with updated links

Step 7: Commit SKU migration

git add docs/sku-standards/
git commit -m "feat: migrate SKU standards from egi-engine

- Comprehensive SKU format documentation
- Platform identifiers and system types
- Links to gen_sku.py and sku_audit.py tools
- Best practices and examples
- CI/CD integration patterns

Migrated from: ~/Developer/egi-engine/standards/sku/

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 8: Migrate Operational Runbooks

Files:

Create: docs/monitoring-incident/runbooks/ (directory)
Migrate all files from ~/Developer/egi-engine/docs/runbooks/
Step 1: Create runbooks directory

mkdir -p docs/monitoring-incident/runbooks

Step 2: Copy and update runbooks

cp ~/Developer/egi-engine/docs/runbooks/*.md docs/monitoring-incident/runbooks/

Step 3: Update runbooks with current tool references

Update each runbook to reference:

Uptime Kuma for monitoring
CrowdSec for security
Slack for alerts
PostHog for analytics
Step 4: Add frontmatter to each runbook

Add YAML frontmatter with title, description, last_updated

Step 5: Verify runbooks section

Run: npm run start and check runbooks in sidebar

Expected: All runbooks visible and navigable

Step 6: Commit runbooks

git add docs/monitoring-incident/runbooks/
git commit -m "feat: migrate operational runbooks from egi-engine

- Engine down procedures
- Deploy new engine
- Database backup and restore
- Bot operator operations
- Control center deployment
- Discovery, tasks, receipts, hello-engine setup

Updated with current tooling stack references.

Migrated from: ~/Developer/egi-engine/docs/runbooks/

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 5: Content Migration from egi-ci:cd

Task 9: Migrate Engineering Standards Documentation

Files:

Update: docs/engineering-standards/repo-conventions.md
Update: docs/engineering-standards/architecture.md
Create: docs/engineering-standards/decisions/ (ADRs)
Create: docs/engineering-standards/ci-cd/ (golden path docs)
Step 1: Copy repo structure doc

cp ~/Developer/egi-ci:cd/docs/repo-structure.md docs/engineering-standards/repo-conventions.md

Step 2: Update repo conventions

Add frontmatter and update references to current tooling

Step 3: Copy architecture doc

cp ~/Developer/egi-ci:cd/docs/architecture.md docs/engineering-standards/architecture.md

Step 4: Update architecture doc

Add frontmatter and update tool references

Step 5: Copy ADRs

mkdir -p docs/engineering-standards/decisions
cp -r ~/Developer/egi-ci:cd/docs/decisions/* docs/engineering-standards/decisions/

Step 6: Copy CI/CD docs

mkdir -p docs/engineering-standards/ci-cd
cp ~/Developer/egi-ci:cd/docs/how-to-bootstrap-new-project.md docs/engineering-standards/ci-cd/
cp ~/Developer/egi-ci:cd/docs/how-to-adapt-existing-project.md docs/engineering-standards/ci-cd/
cp ~/Developer/egi-ci:cd/docs/provider-adapters.md docs/engineering-standards/ci-cd/

Step 7: Update all migrated files

Add frontmatter and update tool references throughout

Step 8: Commit engineering standards migration

git add docs/engineering-standards/
git commit -m "feat: migrate engineering standards from egi-ci:cd

- Repository conventions and structure
- Architecture principles and patterns
- Architecture Decision Records (ADRs)
- CI/CD golden path documentation
- Project bootstrap and adaptation guides
- Provider adapter documentation

Updated with current tooling stack.

Migrated from: ~/Developer/egi-ci:cd/docs/

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 6: Create Content for Remaining Sections

Task 10: Create Company Operations Pages

Files:

Create: docs/company-operations/communication-standards.md
Create: docs/company-operations/slack-conventions.md
Create: docs/company-operations/ownership-model.md
Create: docs/company-operations/documentation-standards.md
Create: docs/company-operations/workflow-rules.md
Step 1: Create communication standards page

Document response times, escalation paths, communication channels (Slack as primary)

Step 2: Create Slack conventions page

Channel naming (e.g., #proj-, #team-, #alert-), threading rules, notification best practices

Step 3: Create ownership model page

RACI framework, assignment process, handoff procedures

Step 4: Create documentation standards page

Frontmatter requirements, markdown conventions, update frequency expectations

Step 5: Create workflow rules page

Approval processes, review cycles, collaboration patterns

Step 6: Commit company operations content

git add docs/company-operations/
git commit -m "feat: create company operations documentation

- Communication standards and expectations
- Slack channel conventions and etiquette
- Ownership model and accountability framework
- Documentation standards and requirements
- Internal workflow rules and processes

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 11: Create Tooling Stack Documentation

Files:

Create: docs/tooling-stack/slack.md
Create: docs/tooling-stack/erpnext.md
Create: docs/tooling-stack/posthog.md
Create: docs/tooling-stack/cloudflare.md
Create: docs/tooling-stack/uptime-kuma.md
Create: docs/tooling-stack/crowdsec.md
Create: docs/tooling-stack/docusaurus.md
Create: docs/tooling-stack/vercel.md
Create: docs/tooling-stack/penpot.md
Create: docs/tooling-stack/stripe.md
Step 1: Create Slack documentation

Purpose, workspace organization, integrations, bot usage

Step 2: Create ERPNext documentation

ERP workflows, module usage, data entry standards

Step 3: Create PostHog documentation

Event tracking, feature flags, session replay, analytics dashboards

Step 4: Create Cloudflare documentation

DNS management, security settings, CDN configuration, Workers usage

Step 5: Create Uptime Kuma documentation

Monitor setup, alert configuration, Slack integration, dashboard access

Step 6: Create CrowdSec documentation

Installation on Linux instances, configuration, alert handling, ban management

Step 7: Create Docusaurus documentation

This site's architecture, contribution workflow, build/deploy process

Step 8: Create Vercel documentation

Deployment configuration, environment variables, preview deployments, domains

Step 9: Create Penpot documentation

Design workflow, file organization, collaboration, export procedures

Step 10: Create Stripe documentation

Payment integration patterns, webhook handling, testing, security best practices

Step 11: Commit tooling stack documentation

git add docs/tooling-stack/
git commit -m "feat: create comprehensive tooling stack documentation

- Slack: Communication and collaboration
- ERPNext: ERP and business processes
- PostHog: Analytics and feature flags
- Cloudflare: DNS, security, CDN
- Uptime Kuma: Monitoring and alerting
- CrowdSec: Intrusion detection
- Docusaurus: This documentation system
- Vercel: Deployment platform
- Penpot: Design tool
- Stripe: Payment processing

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 12: Create Monitoring & Incident Response Pages

Files:

Create: docs/monitoring-incident/monitoring-standards.md
Create: docs/monitoring-incident/health-checks.md
Create: docs/monitoring-incident/alert-routing.md
Create: docs/monitoring-incident/outage-response.md
Create: docs/monitoring-incident/degraded-service.md
Create: docs/monitoring-incident/rollback-procedures.md
Create: docs/monitoring-incident/incident-response.md
Create: docs/monitoring-incident/postmortem-template.md
Step 1: Create monitoring standards

Uptime Kuma setup, CrowdSec configuration, alert thresholds, dashboard organization

Step 2: Create health checks page

Health check endpoints, response format, timeout expectations, frequency

Step 3: Create alert routing page

Slack channel routing (#alerts-critical, #alerts-warning), escalation paths, on-call rotation

Step 4: Create outage response page

Step-by-step outage response, communication templates, status page updates

Step 5: Create degraded service page

Identification, response procedures, partial restoration strategies

Step 6: Create rollback procedures

When to rollback, how to execute, verification steps, communication

Step 7: Create incident response page

Comprehensive incident handling workflow, roles, communication, resolution

Step 8: Create postmortem template

Standardized template with timeline, root cause, action items

Step 9: Commit monitoring & incident documentation

git add docs/monitoring-incident/
git commit -m "feat: create monitoring and incident response documentation

- Monitoring standards (Uptime Kuma, CrowdSec)
- Health check expectations
- Alert routing and escalation
- Outage and degraded service response
- Rollback procedures
- Incident response workflow
- Postmortem template

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 13: Create Remaining Section Content

Files:

All remaining pages in product-operations/, client-delivery/, pricing-standards/, auth-access/, onboarding-offboarding/, migration-archival/
Step 1: Create all product operations pages

product-lifecycle.md, launch-checklist.md, release-checklist.md, analytics-instrumentation.md, feature-flags.md, support-ownership.md

Step 2: Create all client delivery pages

onboarding-workflow.md, documentation-expectations.md, handoff-procedures.md, deployment-standards.md, ownership-model.md, support-model.md

Step 3: Create all pricing standards pages

pricing-methodology.md, estimation-standards.md, packaging-rules.md, stripe-integration.md, calculator-reference.md, pricing-tiers.md

Step 4: Create all auth & access pages

auth-patterns.md, access-expectations.md, documenting-auth.md, account-provisioning.md, future-planning.md

Step 5: Create all onboarding & offboarding pages

employee-setup.md, account-access.md, tools-required.md, documentation-expectations.md, offboarding-procedures.md

Step 6: Create all migration & archival pages

system-migration.md, domain-cutover.md, backup-verification.md, rollback-planning.md, legacy-labeling.md, archival-procedures.md

Step 7: Commit all remaining content

git add docs/
git commit -m "feat: create remaining section documentation

Product Operations:
- Product lifecycle and launch/release checklists
- PostHog analytics instrumentation
- Feature flag standards
- Support ownership model

Client Delivery:
- Onboarding workflow and handoff procedures
- Documentation and deployment standards
- Ownership and support models

Pricing Standards:
- Pricing methodology and estimation
- Packaging rules and Stripe integration
- Calculator reference and pricing tiers

Auth & Access:
- Authentication patterns and access policies
- Account provisioning and future planning

Onboarding & Offboarding:
- Employee setup and tool access
- Documentation expectations and handoff

Migration & Archival:
- System migration and domain cutover
- Backup verification and rollback planning
- Legacy labeling and archival procedures

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 7: Templates & Reference Library

Task 14: Create All Document Templates

Files:

Create: docs/reference-library/templates/sop-template.md
Create: docs/reference-library/templates/system-profile-template.md
Create: docs/reference-library/templates/execution-brief-template.md
Create: docs/reference-library/templates/incident-report-template.md
Create: docs/reference-library/templates/migration-checklist.md
Create: docs/reference-library/templates/domain-cutover-checklist.md
Create: docs/reference-library/templates/repo-audit-checklist.md
Create: docs/reference-library/templates/product-launch-checklist.md
Create: docs/reference-library/templates/client-onboarding-checklist.md
Create: docs/reference-library/templates/uptime-monitoring-checklist.md
Step 1: Create SOP template

Standard operating procedure template with sections: Purpose, Scope, Prerequisites, Procedure, Verification, Troubleshooting, Related Docs

Step 2: Create system profile template

System documentation template with: Overview, Tech Stack, Deployment, Monitoring, Auth, Runbooks, Contacts

Step 3: Create execution brief template

Project execution template with: Objective, Scope, Stakeholders, Timeline, Deliverables, Risks, Success Criteria

Step 4: Create incident report template

Incident report template with: Summary, Timeline, Impact, Root Cause, Resolution, Action Items

Step 5: Create migration checklist

Migration checklist with: Pre-migration, Execution, Validation, Rollback, Post-migration, Communication

Step 6: Create domain cutover checklist

DNS cutover checklist with: Preparation, TTL reduction, Cutover steps, Verification, Rollback, Monitoring

Step 7: Create repo audit checklist

Repository audit checklist with: Documentation, Tests, CI/CD, Security, Dependencies, Standards, License

Step 8: Create product launch checklist

Launch checklist with: Pre-launch (analytics, monitoring, docs, tests), Launch, Post-launch, Rollback criteria

Step 9: Create client onboarding checklist

Client onboarding with: Kickoff, Access provisioning, Documentation, Handoff, Support setup

Step 10: Create uptime monitoring checklist

Uptime Kuma setup with: Service ID, Health checks, Alerts, Slack integration, Verification, Documentation

Step 11: Commit all templates

git add docs/reference-library/templates/
git commit -m "feat: create comprehensive document templates

- SOP template for standard operating procedures
- System profile template for system documentation
- Execution brief template for project planning
- Incident report template for postmortems
- Migration checklist for system migrations
- Domain cutover checklist for DNS changes
- Repository audit checklist for compliance
- Product launch checklist for releases
- Client onboarding checklist for new clients
- Uptime monitoring checklist for Kuma setup

All templates include clear sections, guidance, and examples.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 15: Create Reference Library Pages

Files:

Create: docs/reference-library/glossary.md
Create: docs/reference-library/naming-conventions.md
Create: docs/reference-library/metadata-schema.md
Create: docs/reference-library/links.md
Step 1: Create glossary

Company terminology: ERP, SKU, ADR, PostHog events, CrowdSec bouncer, etc.

Step 2: Create naming conventions

Naming standards for: repos, Slack channels, env variables, file naming, branch naming

Step 3: Create metadata schema

Standard frontmatter fields, tags, categories, required vs optional metadata

Step 4: Create links directory

Important links: ERPNext, PostHog dashboard, Uptime Kuma, Vercel, repos, etc.

Step 5: Commit reference library

git add docs/reference-library/
git commit -m "feat: create reference library pages

- Glossary of company terminology
- Naming conventions across all systems
- Metadata schema for documentation
- Links directory for quick access

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 8: Blog & Authors

Task 16: Set Up Blog

Files:

Create: blog/authors.yml
Create: blog/2026-03-25-welcome.md
Step 1: Create authors file

blog/authors.yml:

egi_team:
  name: EGI Team
  title: EGIntegrations Team
  url: https://egintegrations.com
  image_url: /img/logo.svg

Step 2: Create welcome blog post

blog/2026-03-25-welcome.md:

---
slug: welcome-to-egi-sop
title: Welcome to EGI SOP
authors: [egi_team]
tags: [sop-update, announcement]
---

# Welcome to EGI SOP

We're excited to launch the EGI Standard Operating Procedures documentation site! This represents a major consolidation of our internal documentation, bringing together content from multiple sources into a single, well-organized system.

<!-- truncate -->

## What's New

**Consolidated Documentation**
All company standards, engineering procedures, and operational workflows are now in one place, making it easier to find information and maintain consistency.

**Updated Tooling Stack**
Documentation now reflects our current consolidated stack:
- Slack for communication
- ERPNext for business processes
- PostHog for analytics
- Cloudflare for DNS and security
- Uptime Kuma for monitoring
- CrowdSec for intrusion detection
- And more!

**Comprehensive Templates**
We've created 10 reusable templates for SOPs, incident reports, migration checklists, and more.

**GitOps Workflow**
All documentation changes go through pull requests, maintaining quality and providing full version history.

## What's Included

- **12 Documentation Sections** covering everything from company operations to migration procedures
- **Migrated Content** from egi-engine and egi-ci:cd
- **Templates & Checklists** for common operational tasks
- **Tooling Stack Documentation** for all our core tools
- **Operational Runbooks** for system management

## Get Started

- [Read the Introduction](/docs/intro)
- [Explore the Tooling Stack](/docs/tooling-stack)
- [Browse Templates](/docs/reference-library/templates)
- [Review Engineering Standards](/docs/engineering-standards)

## Contributing

Found something missing or outdated? Follow our GitOps workflow to contribute:
1. Create a feature branch
2. Make your changes
3. Open a pull request
4. Team reviews and merges

Questions? Ask in #egi-sop on Slack.

---

*The EGI Team*

Step 3: Verify blog

Run: npm run start and navigate to /blog

Expected: Blog post displays with author info

Step 4: Commit blog setup

git add blog/
git commit -m "feat: set up blog with welcome post

- Authors configuration
- Welcome post announcing EGI SOP launch
- Blog tags and categories

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 9: README & Documentation

Task 17: Create Comprehensive README

Files:

Create: README.md
Step 1: Write comprehensive README

# EGI SOP - Internal Documentation Site

EGIntegrations Standard Operating Procedures and Internal Documentation Library built with Docusaurus.

## Overview

EGI-SOP serves as the central source of truth for:
- Company operations and communication standards
- Engineering standards and CI/CD golden path
- Product operations and client delivery processes
- SKU standards and pricing methodology
- Tooling stack documentation
- Operational runbooks and incident response
- Templates and reference materials

## Tech Stack

- **Framework**: Docusaurus v3
- **Runtime**: Node.js 18+
- **Package Manager**: npm
- **Hosting**: Vercel
- **Search**: @cmfcmf/docusaurus-search-local

## Getting Started

### Prerequisites

- Node.js 18.x or later
- npm 9.x or later
- Git

### Installation

```bash
# Clone the repository
git clone <repo-url>
cd egi-sop

# Install dependencies
npm install

# Start development server
npm run start

The site will be available at http://localhost:3000.

Build for Production

# Build static files
npm run build

# Serve built files locally
npm run serve

Project Structure

egi-sop/
├── docs/              # Documentation content
├── blog/              # Changelog and announcements
├── src/
│   ├── css/          # Custom styles (EGI branding)
│   ├── components/   # React components
│   └── pages/        # Custom pages
├── static/
│   └── img/          # Images and assets
├── docusaurus.config.js  # Docusaurus configuration
└── sidebars.js       # Sidebar navigation

Documentation Sections

Company Operations - Communication, Slack conventions, ownership
Engineering Standards - Development workflow, CI/CD, architecture
Product Operations - Product lifecycle, launches, analytics
Client Delivery - Onboarding, handoff, support
SKU Standards - SKU format and versioning
Pricing Standards - Pricing methodology and Stripe integration
Tooling Stack - Documentation for all EGI tools
Auth & Access - Authentication patterns and provisioning
Monitoring & Incident Response - Monitoring, alerts, runbooks
Onboarding & Offboarding - Employee lifecycle
Migration & Archival - System migrations and archival
Reference Library - Templates, glossary, quick references

Contributing

Workflow

Create a feature branch
```
git checkout -b feature/topic-name
```
Make your changes
- Edit markdown files in docs/ or blog/
- Add images to static/img/
- Update sidebar in sidebars.js if adding new pages
Test locally
```
npm run start
```

Commit your changes

git add .
git commit -m "feat: descriptive commit message"

Push and open PR
```
git push origin feature/topic-name
```
Then open a pull request on GitHub/GitLab.
Review and merge
- Team reviews via PR comments
- Vercel creates preview deployment
- Merge to main after approval

Frontmatter Standards

All documentation pages should include:

---
title: Page Title
description: Brief description (used for SEO)
sidebar_position: 1  # Optional: controls order in sidebar
last_updated: 2026-03-25
tags: [tag1, tag2]  # Optional
---

Markdown Conventions

Headings: Use H2 (##) for main sections, H3 for subsections
Code blocks: Include language hint for syntax highlighting
Links: Use relative paths for internal links
Images: Store in static/img/, reference as /img/filename.png
Admonitions: Use :::tip, :::warning, :::info, :::danger for callouts

Adding New Pages

Create markdown file in appropriate docs/ subdirectory
Add frontmatter (see above)
Update sidebars.js to include new page in navigation
Test locally to verify navigation works

Blog Posts

Create blog posts in blog/ directory:

---
slug: post-slug
title: Post Title
authors: [egi_team]
tags: [sop-update, tooling, etc]
---

Brief excerpt shown in listing.

<!-- truncate -->

Full post content here.

Deployment

Automatic Deployment (Vercel)

Production: Commits to main → auto-deploy to production
Preview: Pull requests → preview deployments with unique URLs

Manual Deployment

If deploying manually:

npm run build
# Upload `build/` directory to hosting

Troubleshooting

Build Errors

Error: Module not found

rm -rf node_modules package-lock.json
npm install

Error: Port 3000 already in use

npm run start -- --port 3001

Broken Links

Run link checker:

npm run build
# Check build output for broken link warnings

Customization

Branding

Edit src/css/custom.css to modify:

Colors (EGI cream, navy, blue)
Fonts
Component styling

Logo

Replace static/img/logo.svg with your logo.

Configuration

Edit docusaurus.config.js for:

Site metadata
Navbar items
Footer links
Plugin configuration

Maintenance

Updating Dependencies

npm update
npm audit fix

Docusaurus Upgrades

Check for Docusaurus updates:

npm outdated @docusaurus/core

Follow Docusaurus upgrade guide.

Support

Questions: #egi-sop on Slack
Issues: GitHub Issues
Documentation: https://docusaurus.io

License

Internal use only - EGIntegrations

Built with Docusaurus

- [ ] **Step 2: Verify README**

Run: `cat README.md | wc -l`

Expected: Comprehensive README with all sections

- [ ] **Step 3: Commit README**

```bash
git add README.md
git commit -m "docs: create comprehensive README

- Getting started and installation
- Project structure overview
- Contributing workflow and standards
- Deployment instructions
- Troubleshooting guide
- Maintenance procedures

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 10: Testing & Verification

Task 18: Comprehensive Testing

Files:

Create: .gitignore (if not exists)
Step 1: Create/verify .gitignore

# Dependencies
/node_modules
/.pnp
.pnp.js

# Production
/build

# Generated files
.docusaurus
.cache-loader

# Misc
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local

npm-debug.log*
yarn-debug.log*
yarn-error.log*

Step 2: Full production build

Run: npm run build

Expected: Build succeeds with no errors

Step 3: Serve production build locally

Run: npm run serve

Expected: Production build serves correctly at http://localhost:3000

Step 4: Test all navigation

Navigate through all 12 sections, verify:

All index pages load
All sub-pages load
Sidebar navigation works
Breadcrumbs work
Internal links work
Step 5: Test search

Search for terms like "SKU", "Slack", "monitoring", "template"

Expected: Search returns relevant results

Step 6: Test blog

Navigate to /blog, verify:

Blog listing shows welcome post
Post detail page loads
Author info displays
Tags work
Step 7: Test dark mode

Toggle dark mode, verify:

Colors invert correctly
Everything remains readable
Images/logo look appropriate
Step 8: Test responsive design

Resize browser to mobile width, verify:

Navigation hamburger menu works
Content is readable
Tables scroll horizontally if needed
Step 9: Document test results

Create: docs/superpowers/test-results.md with findings

Step 10: Commit testing updates

git add .gitignore docs/superpowers/test-results.md
git commit -m "test: comprehensive site testing

- Verified production build
- Tested all navigation paths
- Verified search functionality
- Tested blog and authors
- Verified dark mode
- Tested responsive design
- Documented test results

All tests passing.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 11: Deployment Preparation

Task 19: Prepare for Vercel Deployment

Files:

Create: vercel.json (optional configuration)
Create: .vercelignore (optional)
Step 1: Create Vercel configuration (optional)

vercel.json:

{
  "buildCommand": "npm run build",
  "outputDirectory": "build",
  "framework": "docusaurus",
  "rewrites": [
    { "source": "/(.*)", "destination": "/" }
  ]
}

Step 2: Create .vercelignore

node_modules
.docusaurus
.cache-loader
docs/superpowers

Step 3: Verify package.json scripts

Ensure package.json has:

{
  "scripts": {
    "docusaurus": "docusaurus",
    "start": "docusaurus start",
    "build": "docusaurus build",
    "swizzle": "docusaurus swizzle",
    "deploy": "docusaurus deploy",
    "clear": "docusaurus clear",
    "serve": "docusaurus serve",
    "write-translations": "docusaurus write-translations",
    "write-heading-ids": "docusaurus write-heading-ids"
  }
}

Step 4: Final production build test

Run: npm run build

Expected: Clean build with no errors or warnings

Step 5: Commit Vercel configuration

git add vercel.json .vercelignore package.json
git commit -m "chore: prepare for Vercel deployment

- Vercel configuration file
- Vercel ignore rules
- Verified build scripts

Ready for deployment.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Task 20: Final Review and Documentation

Files:

Update: docs/intro.md
Create: DEPLOYMENT.md
Step 1: Create deployment guide

DEPLOYMENT.md:

# Deployment Guide

## Vercel Deployment

### Initial Setup

1. **Connect Repository to Vercel**
   - Go to https://vercel.com
   - Click "Add New Project"
   - Import your git repository
   - Select framework: Docusaurus

2. **Configure Build Settings**
   - Build Command: `npm run build`
   - Output Directory: `build`
   - Install Command: `npm install`
   - Development Command: `npm run start`

3. **Add Environment Variables** (if needed)
   - None required for initial deployment

4. **Deploy**
   - Click "Deploy"
   - Wait for build to complete
   - Verify deployment at generated URL

### Custom Domain

1. **Add Domain in Vercel**
   - Project Settings → Domains
   - Add domain: `sop.egintegrations.com`

2. **Configure DNS (Cloudflare)**
   - Add CNAME record pointing to Vercel

3. **Verify SSL**
   - Vercel automatically provisions SSL certificate

### Automatic Deployments

- **Production**: Every push to `main` branch
- **Preview**: Every pull request

### Manual Deployment

If needed, deploy manually:

```bash
npm run build
vercel --prod

Rollback

Via Vercel Dashboard

Go to Deployments
Find previous successful deployment
Click "Promote to Production"

Via Git

git revert <commit-hash>
git push origin main

Monitoring

Deployment status: Vercel dashboard
Build logs: Available in Vercel
Analytics: Vercel Analytics (optional)

Troubleshooting

Build Fails

Check build logs in Vercel
Reproduce locally with npm run build
Fix errors and push

Site Not Updating

Verify deployment completed successfully
Clear browser cache
Check Vercel deployment logs

Support

Questions? Ask in #egi-sop on Slack.

- [ ] **Step 2: Update intro.md with deployment status**

Add to bottom of `docs/intro.md`:

```markdown
## Deployment

This site is deployed on Vercel with automatic deployments:
- **Production**: https://sop.egintegrations.com (when configured)
- **Repository**: (link to git repo)

See [DEPLOYMENT.md](../DEPLOYMENT.md) for deployment procedures.

Step 3: Create contribution quick start

Add to README.md section "Quick Contribution Guide"

Step 4: Final commit

git add DEPLOYMENT.md docs/intro.md README.md
git commit -m "docs: add deployment guide and final documentation

- Comprehensive Vercel deployment guide
- Rollback procedures
- Troubleshooting steps
- Updated intro with deployment info
- Quick contribution guide

Documentation complete and ready for deployment.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Phase 12: Final Verification

Task 21: Complete Implementation Checklist

Verification Checklist:

Step 1: Verify all 12 documentation sections exist

Check:

company-operations/
engineering-standards/
product-operations/
client-delivery/
sku-standards/
pricing-standards/
tooling-stack/
auth-access/
monitoring-incident/
onboarding-offboarding/
migration-archival/
reference-library/
Step 2: Verify all migrations completed

Check:

SKU standards from egi-engine ✓
Runbooks from egi-engine ✓
Engineering standards from egi-ci:cd ✓
ADRs from egi-ci:cd ✓
CI/CD docs from egi-ci:cd ✓
Step 3: Verify all templates created

Check 10 templates exist in reference-library/templates/

Step 4: Verify tooling stack documentation

Check all 10 tools documented: Slack, ERPNext, PostHog, Cloudflare, Uptime Kuma, CrowdSec, Docusaurus, Vercel, Penpot, Stripe

Step 5: Verify branding applied

Check:

EGI colors (cream, navy, blue)
Logo in navbar
Custom CSS loaded
Dark mode works
Step 6: Verify blog setup

Check:

authors.yml exists
Welcome post exists
Blog accessible at /blog
Step 7: Verify README and documentation

Check:

README.md comprehensive
DEPLOYMENT.md exists
Contributing guidelines clear
Step 8: Final build test

Run: npm run build

Expected: Clean build, no errors

Step 9: Create implementation completion report

Create: docs/superpowers/implementation-complete.md

Document:

All completed tasks
Migration sources
Testing results
Deployment readiness
Step 10: Final commit

git add docs/superpowers/implementation-complete.md
git commit -m "chore: complete EGI SOP implementation

All phases complete:
✅ Phase 1: Project initialization
✅ Phase 2: Branding and styling
✅ Phase 3: Core documentation structure
✅ Phase 4: Content migration from egi-engine
✅ Phase 5: Content migration from egi-ci:cd
✅ Phase 6: Remaining section content
✅ Phase 7: Templates and reference library
✅ Phase 8: Blog and authors
✅ Phase 9: README and documentation
✅ Phase 10: Testing and verification
✅ Phase 11: Deployment preparation
✅ Phase 12: Final verification

12 documentation sections created
10 templates implemented
All migrations completed
Branding applied
Blog configured
Documentation comprehensive
Testing complete
Ready for deployment

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"

Success Criteria Verification

The implementation is complete when all of the following are verified:

✅ Structure: All 12 documentation sections created with proper navigation
✅ Content: Existing documentation migrated from egi-engine and egi-ci:cd
✅ Updates: All tool references updated to reflect consolidated stack
✅ Templates: All 10 required templates created and documented
✅ Branding: EGI branding applied (colors, typography, logo)
✅ Blog: Blog setup with example posts
✅ Deployment: Site ready for Vercel deployment with GitOps workflow
✅ Documentation: README and contribution guidelines complete
✅ Testing: All links work, site builds without errors, search functional
✅ Handoff: Documentation complete for team contribution workflow

Post-Implementation Tasks

After deployment, complete these tasks:

Set up Vercel project and configure custom domain
Configure Cloudflare DNS to point to Vercel
Test production deployment thoroughly
Create Slack channel #egi-sop for announcements
Announce to team with introduction and contribution guide
Schedule review for one week post-launch to gather feedback
Plan content updates based on team needs

Notes for Agentic Workers

Each task is designed to be self-contained and take 5-15 minutes
Commits should be made after each task completion
Always test locally with npm run start before committing
Verify builds with npm run build periodically
Follow frontmatter standards for all markdown files
Maintain EGI branding consistency throughout
Update tool references to consolidated stack in all migrated content
Test navigation and search after adding significant content

File Structure​

Phase 1: Project Initialization​

Task 1: Initialize Docusaurus Project​

Task 2: Configure Docusaurus for EGI​

Task 3: Configure Sidebar Navigation​

Phase 2: Branding & Custom Styling​

Task 4: Apply EGI Branding​

Task 5: Create Custom Homepage​

Phase 3: Core Documentation Structure​

Task 6: Create Introduction and Core Index Pages​

Phase 4: Content Migration from egi-engine​

Task 7: Migrate SKU Standards Documentation​

Task 8: Migrate Operational Runbooks​

Phase 5: Content Migration from egi-ci:cd​

Task 9: Migrate Engineering Standards Documentation​

Phase 6: Create Content for Remaining Sections​

Task 10: Create Company Operations Pages​

Task 11: Create Tooling Stack Documentation​

Task 12: Create Monitoring & Incident Response Pages​

Task 13: Create Remaining Section Content​

Phase 7: Templates & Reference Library​

Task 14: Create All Document Templates​

Task 15: Create Reference Library Pages​

Phase 8: Blog & Authors​

Task 16: Set Up Blog​

Phase 9: README & Documentation​

Task 17: Create Comprehensive README​

Build for Production​

Project Structure​

Documentation Sections​

Contributing​

Workflow​

Frontmatter Standards​

Markdown Conventions​

Adding New Pages​

Blog Posts​

Deployment​

Automatic Deployment (Vercel)​

Manual Deployment​

Troubleshooting​

Build Errors​

Broken Links​

Customization​

Branding​

Logo​

Configuration​

Maintenance​

Updating Dependencies​

Docusaurus Upgrades​

Support​

License​

Phase 10: Testing & Verification​

Task 18: Comprehensive Testing​

Phase 11: Deployment Preparation​

Task 19: Prepare for Vercel Deployment​

Task 20: Final Review and Documentation​

Rollback​

Via Vercel Dashboard​

Via Git​

Monitoring​

Troubleshooting​

Build Fails​

Site Not Updating​

Support​

Phase 12: Final Verification​

Task 21: Complete Implementation Checklist​

Success Criteria Verification​

Post-Implementation Tasks​

Notes for Agentic Workers​

File Structure

Phase 1: Project Initialization

Task 1: Initialize Docusaurus Project

Task 2: Configure Docusaurus for EGI

Task 3: Configure Sidebar Navigation

Phase 2: Branding & Custom Styling

Task 4: Apply EGI Branding

Task 5: Create Custom Homepage

Phase 3: Core Documentation Structure

Task 6: Create Introduction and Core Index Pages

Phase 4: Content Migration from egi-engine

Task 7: Migrate SKU Standards Documentation

Task 8: Migrate Operational Runbooks

Phase 5: Content Migration from egi-ci:cd

Task 9: Migrate Engineering Standards Documentation

Phase 6: Create Content for Remaining Sections

Task 10: Create Company Operations Pages

Task 11: Create Tooling Stack Documentation

Task 12: Create Monitoring & Incident Response Pages

Task 13: Create Remaining Section Content

Phase 7: Templates & Reference Library

Task 14: Create All Document Templates

Task 15: Create Reference Library Pages

Phase 8: Blog & Authors

Task 16: Set Up Blog

Phase 9: README & Documentation

Task 17: Create Comprehensive README

Build for Production

Project Structure

Documentation Sections

Contributing

Workflow

Frontmatter Standards

Markdown Conventions

Adding New Pages

Blog Posts

Deployment

Automatic Deployment (Vercel)

Manual Deployment

Troubleshooting

Build Errors

Broken Links

Customization

Branding

Logo

Configuration

Maintenance

Updating Dependencies

Docusaurus Upgrades

Support

License

Phase 10: Testing & Verification

Task 18: Comprehensive Testing

Phase 11: Deployment Preparation

Task 19: Prepare for Vercel Deployment

Task 20: Final Review and Documentation

Rollback

Via Vercel Dashboard

Via Git

Monitoring

Troubleshooting

Build Fails

Site Not Updating

Support

Phase 12: Final Verification

Task 21: Complete Implementation Checklist

Success Criteria Verification

Post-Implementation Tasks

Notes for Agentic Workers