Vertical Delivery Checklist

The 10-step Vertical Delivery Checklist is the canonical process for building and deploying a vertical application on the Enterprise AI platform. Each step has a corresponding Claude Code skill or manual action, along with a verification criterion that must pass before proceeding.

This checklist is extracted from the CLAUDE.md file in the Vertical Template repository and represents the recommended order of operations.

Checklist Overview

Step	Action	Skill / Tool	Verification
1	Gather requirements	Manual	Requirements document exists
2	Define object types	`/define-object-types`	Types compile, all properties typed
3	Create tenant config	`/add-tenant`	Config registered in `index.ts`
4	Set up data access	`/setup-data-access`	Hooks compile, use Platform SDK
5	Build domain UI	`/add-page`	Pages render with data
6	Configure AI	`/configure-ai`	Chat streams, docs upload
7	Set deployment config	`/deploy-vertical`	Workflow file updated
8	Seed object types	`/seed-configurator`	All types seeded, no duplicates
9	Deploy	`git push origin main`	App loads at `/{app-name}`
10	Verify	`verifyPlatform()`	All checks pass

Step 1: Gather Requirements

Action: Understand the domain, entities, workflows, and AI needs.

How: Work with stakeholders or describe the domain to your AI assistant. Identify:

The main entities (e.g., Applications, Documents, Users)
Relationships between entities (e.g., an Application has many Documents)
Workflow actions (e.g., submit, approve, reject)
AI needs (e.g., RAG chat for regulations, document classification)
Tenant/branding requirements

Output: A clear understanding of the data model, user flows, and feature requirements. This does not need to be a formal document -- a conversation with your AI assistant is sufficient.

Verification: You can articulate what the vertical does, what entities it manages, and what AI features it needs.

Step 2: Define Object Types

Action: Create the data model in code.

Skill: /define-object-types

What happens: The skill edits src/eai.config/object-types.ts to define your domain entities using the Object Type schema format. Each entity gets:

Properties with types (text, number, boolean, date, select, json, file, relationship)
Link types for relationships between entities
Actions for workflow transitions (with role requirements, validation rules, and side effects)

Key file: src/eai.config/object-types.ts

Verification:

npx tsc --noEmit

All object types compile without errors. Every property has a valid type, select fields have options arrays, and actions have requiredRole set.

Step 3: Create Tenant Config

Action: Create a tenant configuration file that defines the UI layout, state management, and features.

Skill: /add-tenant

What happens: The skill creates src/eai.config/tenants/{tenant-id}.config.ts with store slices, layout declarations, conditional rendering rules, and optional theming. It then registers the config in src/eai.config/index.ts.

Key files:

src/eai.config/tenants/{tenant-id}.config.ts -- Tenant configuration
src/eai.config/index.ts -- Config registry

Verification: The tenant config file exists, exports a valid EAIConfig object, and is imported and registered in the config map in index.ts.

Step 4: Set Up Data Access

Action: Generate typed React hooks for CRUD operations on each entity.

Skill: /setup-data-access

What happens: For each object type, the skill generates a hook file at src/hooks/use{EntityName}s.ts with:

A TypeScript interface matching the object type properties
A hook function that delegates to useResources<T> from the Platform SDK
Full CRUD support: list, get, create, update, delete, executeAction

Key files:

src/hooks/useResources.ts -- Generic CRUD hook (base)
src/hooks/use{Entity}s.ts -- Entity-specific hooks (generated)

Verification:

npx tsc --noEmit

All hooks compile. Each hook uses the Platform SDK (not raw fetch). The update method signature includes the version parameter for optimistic locking.

Step 5: Build Domain UI

Action: Create pages in the Next.js application that use the data access hooks.

Skill: /add-page (invoke for each page)

What happens: For each page, the skill creates:

A page component at src/app/(presentation)/{path}/page.tsx
Authentication checks (if the page is protected)
SEO metadata
Loading skeleton (loading.tsx)
Error boundary (error.tsx)

Key directory: src/app/(presentation)/

Verification: Pages render correctly in the browser. Protected pages redirect unauthenticated users. Data from hooks displays properly.

Step 6: Configure AI

Action: Set up AI chat workflows and document processing.

Skill: /configure-ai

What happens: The skill:

Creates a workflow record in Configurator with stage definitions and system prompts
Sets the WORKFLOW_*_ID environment variable
Wires the useChat hook for SSE streaming through the stream proxy
Wires the useDocuments hook for file uploads and AI classification
Verifies the SSE stream proxy exists

Key files:

src/hooks/useChat.ts -- Chat streaming hook
src/hooks/useDocuments.ts -- Document processing hook
src/app/api/eai/stream/[[...rest]]/route.ts -- SSE proxy

Verification: Chat messages stream in real time via SSE. Documents can be uploaded and classified. The full chain works: Browser -> BFF Stream Proxy -> PublicAPI -> AICore.

note

If your vertical does not need AI features, this step can be skipped.

Step 7: Set Deployment Config

Action: Configure the CI/CD pipeline for Azure deployment.

Skill: /deploy-vertical

What happens: The skill:

Sets APP_NAME in .github/workflows/deploy-demo.yml
Documents required GitHub secrets
Registers the app in demo-infra infrastructure
Seeds Azure App Configuration with environment values

Key files:

.github/workflows/deploy-demo.yml -- GitHub Actions workflow
.env.local -- Local environment variables

Verification: The APP_NAME is set in the workflow file. GitHub secrets are configured. The app is registered in the infrastructure.

Step 8: Seed Object Types

Action: Push the object type definitions to the Configurator service.

Skill: /seed-configurator

What happens: The skill reads object-types.ts, checks for existing types in Configurator (idempotency), and creates or updates each type via the orchestrate endpoint. Results are reported per type (created / updated / skipped).

Key files:

src/eai.config/object-types.ts -- Source of truth for types
src/lib/platform/seed-object-types.ts -- Seeding utility

Verification:

import { verifyPlatform } from '@/lib/platform/verify-platform';
const status = await verifyPlatform('my-tenant');
// { configurator: true, resourceApi: true, crud: true }

All object types exist in Configurator. No duplicates created. Each type is linked to the correct tenant.

Step 9: Deploy

Action: Push to main to trigger the GitHub Actions deployment workflow.

Command:

git push origin main

Or trigger manually:

gh workflow run deploy-demo.yml

What happens: GitHub Actions builds the Next.js application with output: 'standalone', deploys to Azure App Service at the configured APP_NAME path, and starts the application.

Verification:

curl -s -o /dev/null -w "%{http_code}" \
  https://app-demo-eai-dev.azurewebsites.net/{app-name}
# Should return 200

The app loads at https://app-demo-eai-dev.azurewebsites.net/{app-name}.

Step 10: Verify

Action: Run the full platform verification to confirm everything works end-to-end.

Verification steps:

Object types in Configurator -- all types exist with correct properties
CRUD works -- create, read, update, delete operations succeed via ResourceAPI
Chat streams -- SSE streaming delivers real-time responses (if AI configured)
UI renders -- all pages load with correct data, authentication works

Programmatic verification:

import { verifyPlatform } from '@/lib/platform/verify-platform';

const status = await verifyPlatform('my-tenant');
console.log(status);
// { configurator: true, resourceApi: true, crud: true }

API verification:

curl https://app-demo-eai-dev.azurewebsites.net/{app-name}/api/eai/config

Manual verification:

Navigate to the app URL in a browser
Sign in with Entra CIAM credentials
Verify the tenant config loads (correct branding, layout)
Create, read, update, and delete a resource
Test chat streaming (send a message, verify SSE response)
Upload and classify a document

Quick Reference: Skill Invocation Order

For a complete vertical build, invoke skills in this order:

/define-object-types     # Step 2: Data model
/add-tenant              # Step 3: Tenant config
/setup-data-access       # Step 4: CRUD hooks
/add-page                # Step 5: UI pages (repeat per page)
/configure-ai            # Step 6: AI features (optional)
/deploy-vertical         # Step 7: Deployment config
/seed-configurator       # Step 8: Push types to platform

Or use /vertical-setup to run the entire sequence in one go.

Checklist Overview​

Step 1: Gather Requirements​

Step 2: Define Object Types​

Step 3: Create Tenant Config​

Step 4: Set Up Data Access​

Step 5: Build Domain UI​

Step 6: Configure AI​

Step 7: Set Deployment Config​

Step 8: Seed Object Types​

Step 9: Deploy​

Step 10: Verify​

Quick Reference: Skill Invocation Order​

Checklist Overview

Step 1: Gather Requirements

Step 2: Define Object Types

Step 3: Create Tenant Config

Step 4: Set Up Data Access

Step 5: Build Domain UI

Step 6: Configure AI

Step 7: Set Deployment Config

Step 8: Seed Object Types

Step 9: Deploy

Step 10: Verify

Quick Reference: Skill Invocation Order