Deployment and Infrastructure

Deployer

Deployment Strategy

Prodgy uses Docker containers for most services, except for the Assistant (.NET) which runs on a Windows VM.

Service	Deploy Method	Recommended Platform
API	Container	Azure Container Apps, ECS, Kubernetes
Web	Container or Static	Azure Static Web Apps, S3 + CloudFront, Vercel
Service	Container	Azure Container Apps, ECS, Kubernetes
Studio	Container	Azure Container Apps, ECS, Kubernetes
Engine	Container	Azure Container Apps, ECS, Kubernetes
Gateway	Container	Azure Container Apps, ECS, Kubernetes
Agentic	Container	Azure Container Apps, ECS, Kubernetes
Assistant	Windows VM	Azure VM, EC2 Windows, bare metal
Docs	Container or Static	Azure Static Web Apps, Vercel, Netlify

Dockerfiles

Each service has its own Dockerfile:

Service	File	Base Image
API	`apps/api/Dockerfile`	`node:18-alpine`
Web	`apps/web/Dockerfile`	`node:18-alpine`
Service	`apps/service/Dockerfile`	`node:18-alpine`
Studio	`apps/studio/Dockerfile`	`node:18-alpine`
Gateway	`apps/gateway/Dockerfile`	`node:18-alpine`
Agentic	`apps/agentic/Dockerfile`	`node:18-alpine`
Engine	`Dockerfile.engine` (root)	`python:3.13-slim`

Building Containers

# API
docker build -f apps/api/Dockerfile -t prodgy-api .

# Web
docker build -f apps/web/Dockerfile -t prodgy-web .

# Service
docker build -f apps/service/Dockerfile -t prodgy-service .

# Studio
docker build -f apps/studio/Dockerfile -t prodgy-studio .

# Gateway
docker build -f apps/gateway/Dockerfile -t prodgy-gateway .

# Agentic
docker build -f apps/agentic/Dockerfile -t prodgy-agentic .

# Engine
docker build -f Dockerfile.engine -t prodgy-engine .

Docker Compose (Local Development)

The docker-compose.yml at the project root configures auxiliary services for local development:

docker compose up -d

Included services:

Redis (port 6379) — queue broker and cache
Redis Commander (port 8081) — web interface for monitoring
Engine (port 8001) — AI engine

CI/CD Pipeline

Prodgy uses Azure DevOps Pipelines with automatic change detection:

Environments

Environment	Trigger	Branch
Development	Auto push	`main`
Staging	Auto push	`staging`
Production	Tag `v*`	Git tags

Change Detection

The pipeline checks which services were changed and only builds/deploys the affected ones:

Change in	Affected Services
`apps/api/`	API only
`apps/web/`	Web only
`apps/service/`	Service only
`apps/studio/`	Studio only
`apps/gateway/`	Gateway only
`apps/agentic/`	Agentic only
`apps/engine/` or `Dockerfile.engine`	Engine only
`apps/assistant/`	Assistant only
`packages/`, `pnpm-lock.yaml`, `turbo.json`	All Node.js services

Per-Environment Variables

Each environment requires a Variable Group in Azure DevOps with:

azureServiceConnection         # Azure RM connection
resourceGroup                  # Resource Group
containerRegistry              # Container Registry name
registryLoginServer            # Registry URL
apiContainerAppName            # API Container App
serviceContainerAppName        # Service Container App
webContainerAppName            # Web Container App
studioContainerAppName         # Studio Container App
gatewayContainerAppName        # Gateway Container App
agenticContainerAppName        # Agentic Container App
engineContainerAppName         # Engine Container App
AZURE_STATIC_WEB_APP_API_TOKEN # Static Web App token
VM_IP                          # Windows VM IP (Assistant)
VM_USER                        # VM username
VM_PASSWORD                    # VM password (secret)

Assistant Deployment (Windows VM)

The Assistant service requires special deployment on a Windows VM:

The pipeline compiles the .NET project
Generates a compressed artifact
Connects to the VM via WinRM (PowerShell remoting)
Stops the service via NSSM
Replaces files (preserving appsettings.Production.json)
Restarts the service

Deployment Checklist

Pre-Deploy

Environment variables configured for the target environment
Service tokens generated (unique per environment)
PostgreSQL/Supabase database provisioned
Redis provisioned and accessible
DNS configured for public services
SSL certificates issued
CORS configured on the API with correct origins

Post-Deploy

Service health checks (API, Engine, Service, Gateway, Agentic)
Authentication test (login, JWT, API tokens)
Inter-service communication test
Verify database connection
Verify Redis connection
Test Playground (send message to an agent)
Check logs for each service