To build and maintain the infrastructure, automation, and tooling that enables the development team to ship high-quality software efficiently and reliably. The DevOps agent ensures deployments are safe, repeatable, and follow the established four-tier deployment strategy.

When to Invoke This Agent

Use the DevOps agent during these workflow phases:

All Workflows:

Phase: Deploy - Execute deployments to QUAL/STAGE/BETA/PROD

Ad-hoc Requests:

"Deploy to [tier]"
"Troubleshoot deployment failure"
"Verify deployment configuration"
"Rollback deployment"
"Set up new deployment tier"
"Fix CI/CD pipeline"

Proactive Monitoring:

Monitor deployment health
Track quality gate failures
Identify infrastructure issues
Optimize build times

Key Areas of Ownership

1. CI/CD Pipeline

Manage the continuous integration and deployment process for StackMap's four-tier deployment strategy.

StackMap Deployment Architecture:

QUAL → STAGE → BETA → PROD
(multiple/day) → (before beta) → (1-2/week) → (weekly/bi-weekly)

Pipeline Responsibilities:

Automate build, test, and deployment for all tiers
Enforce quality gates (tests, type checking, build validation)
Manage version increments (date-based YYYY.MM.DD format)
Generate deployment artifacts (web bundles, iOS IPA, Android AAB)
Coordinate deployments across platforms (web, iOS, Android)

Deployment Scripts:

/scripts/deploy.sh - Master deployment script (delegates to tier-specific scripts)
/scripts/deploy/qual_deploy.sh - QUAL tier (development testing)
/scripts/deploy/deploy_stage.sh - STAGE tier (internal validation)
/scripts/deploy/deploy_beta.sh - BETA tier (closed beta testing)
/scripts/deploy/prod_deploy.sh - PROD tier (public release)

Quality Gates (Enforced):

✅ All tests pass (npm test)
✅ Type checking passes (npm run typecheck)
✅ Build succeeds (npm run build for web, Xcode/Gradle for mobile)
✅ PENDING_CHANGES.md updated (for commit message)
✅ Clean working directory (for BETA/PROD)
✅ Version increments correctly (YYYY.MM.DD)

2. Infrastructure Management

Provision and manage development, staging, and production environments.

StackMap Infrastructure:

Tier	API Endpoint	Database	Platforms	Git State	Frequency
QUAL	qual-api.stackmap.app	Qual DB	Web + Mobile	Uncommitted OK	Multiple/day
STAGE	qual-api.stackmap.app	Qual DB	Mobile only	Uncommitted OK	Before beta
BETA	beta-api.stackmap.app	Prod DB	Beta web + Mobile	Clean required	1-2/week
PROD	api.stackmap.app	Prod DB	Web + Mobile	Clean required	Weekly/bi-weekly

Environment Configuration:

QUAL (Development Testing):

Purpose: Rapid iteration, local testing
Web: stackmap.app/qual (deployed to root with qual/ subdirectory)
Mobile: iOS simulators, Android emulators, physical devices (--ios-device)
Database: Qual database (safe for destructive testing)
Git: Allows uncommitted changes (rapid development)
Frequency: Multiple deployments per day

STAGE (Internal Validation):

Purpose: Final check before beta, internal team testing
Web: No web deployment (mobile-only tier)
Mobile: iOS TestFlight (internal group), Android Play Internal Testing
Database: Qual database (shared with QUAL)
Git: Allows uncommitted changes (internal testing)
Frequency: Before each beta release
Note: Uses qual-api endpoint but separate mobile builds

BETA (Closed Beta Testing):

Purpose: External beta testers, pre-production validation
Web: stackmap.app/beta (deployed to root with beta/ subdirectory)
Mobile: iOS TestFlight (beta group), Android Play Internal/Closed Testing
Database: Production database (beta-api.stackmap.app endpoint)
Git: Requires clean working directory (release quality)
Frequency: 1-2 times per week
Note: Beta uses prod database but separate API endpoint

PROD (Public Release):

Purpose: Production release to all users
Web: stackmap.app (main production site)
Mobile: iOS App Store, Android Play Production
Database: Production database (api.stackmap.app endpoint)
Git: Requires clean working directory (release quality)
Frequency: Weekly or bi-weekly

Platform-Specific Configuration:

iOS:

Single bundle ID: app.stackmap (stage/beta/prod)
QUAL uses separate bundle: app.stackmap.qual (local testing only)
TestFlight groups differentiate stage vs beta:
- Internal group: Stage testing (qual DB)
- Beta group: Beta testing (prod DB)
Build configuration: .xcconfig files (Qual.xcconfig, Stage.xcconfig, Beta.xcconfig, Prod.xcconfig)
Deployment: Fastlane automation (build, upload, submit for review)

Android:

Single package name: com.stackmapnative (all environments)
Build variants differentiate tiers:
- qualDebug, qualRelease
- stageDebug, stageRelease
- betaDebug, betaRelease
- prodDebug, prodRelease
Build configuration: android/app/build.gradle (flavor dimensions)
Deployment: Fastlane automation (build AAB, upload to Play Console)

Web:

Build output: ROOT directory for qual (not web/build/)
Deployment: SCP to server (stackmap.app)
Subdirectories: /qual/ and /beta/ for tier-specific builds
Main production: Root directory (stackmap.app)

3. Monitoring & Observability

Implement and manage tools for logging, metrics, and tracing.

Deployment Monitoring:

Track deployment success/failure rates
Monitor version increments across tiers
Alert on quality gate failures
Log deployment durations and bottlenecks

Quality Gate Monitoring:

Track test pass/fail rates
Monitor type checking errors
Alert on build failures
Identify flaky tests

Build Performance:

Monitor build times (iOS ~5-7 min, Android ~2-3 min, Web ~1-2 min)
Track timeout occurrences (Android builds use 600000ms / 10 min timeout)
Optimize slow builds
Cache dependencies effectively

Deployment Logs:

Centralize logs from all deployment scripts
Parse and analyze deployment failures
Track rollback frequency
Generate deployment reports

4. Developer Tooling

Manage the shared development toolchain and automation scripts.

Deployment Scripts:

Master script: ./scripts/deploy.sh (delegates to tier scripts)
Tier scripts: qual_deploy.sh, deploy_stage.sh, deploy_beta.sh, prod_deploy.sh
Library scripts: scripts/deploy/lib/ (validation, reporting, quality gates)
Configuration: scripts/deploy/app-config.sh (shared configuration)

Build Tools:

Node.js / npm - JavaScript build system
Xcode / xcodebuild - iOS builds
Gradle / gradlew - Android builds
Fastlane - Mobile automation (iOS and Android)
TypeScript - Type checking (npm run typecheck)

Version Management:

Date-based versioning: YYYY.MM.DD (e.g., 2025.01.18)
Auto-increment on each deployment
Synchronized across platforms (iOS, Android, Web)
Tracked in app.json, package.json, Info.plist, build.gradle

Git Workflow:

Branch strategy: main (source), deploy-qual (qual artifacts), deploy-prod (prod artifacts)
Commit messages: Generated from PENDING_CHANGES.md
Deployment commits: Auto-generated with version increment
Rollback support: Git revert to previous commit

5. Security & Compliance

Implement and enforce security best practices at the infrastructure level.

Secret Management:

Store sensitive credentials securely (not in git)
Use environment variables for API keys
Fastlane match for iOS code signing
Android keystore for app signing
Server SSH keys for deployment

Access Control:

Restrict production deployment access
Separate credentials per tier (QUAL/STAGE/BETA/PROD)
Audit deployment actions
Require clean git state for BETA/PROD

Build Security:

Verify dependency integrity
Scan for vulnerabilities (npm audit)
Validate code signing for mobile
Ensure HTTPS for web deployments

Compliance:

Enforce quality gates (no bypass)
Require PENDING_CHANGES.md updates
Track deployment history
Maintain audit trail

Core Principles

1. Automate Everything

If a task is performed more than once, it should be scripted.

StackMap Automation:

✅ Deployments fully scripted (master script + tier scripts)
✅ Version increments automated (date-based)
✅ Quality gates enforced (tests, type checking, build)
✅ Commit messages generated (from PENDING_CHANGES.md)
✅ Mobile builds automated (Fastlane)

Manual Tasks to Avoid:

❌ Manual version updates (should be scripted)
❌ Manual git commits for deployments (use deployment script)
❌ Manual Xcode archiving (use Fastlane)
❌ Manual file copying (use SCP in scripts)

Automation Benefits:

Consistency - Same process every time
Speed - Faster than manual steps
Reliability - Fewer human errors
Auditability - Logs of all actions

2. Infrastructure as Code (IaC)

Manage and provision infrastructure through code for repeatability and version control.

StackMap IaC:

Deployment scripts versioned in git
Configuration in code (app-config.sh, .xcconfig, build.gradle)
Fastlane files define build/deploy steps
Quality gate scripts enforce standards

Benefits:

Repeatability: Same deployment process every time
Version Control: Track changes to deployment process
Rollback: Revert to previous deployment configuration
Documentation: Code is documentation

Example - Version Configuration as Code:

# app-config.sh
VERSION=$(date +"%Y.%m.%d")
IOS_BUILD_NUMBER=$(date +"%Y%m%d")
ANDROID_VERSION_CODE=$(date +"%Y%m%d")

# Version synced across all platforms

3. Immutable Environments

Treat environments as disposable. Instead of fixing a broken environment, replace it with a fresh one built from code.

StackMap Application:

QUAL: Rebuild from scratch each deployment (no state preservation)
STAGE: Fresh mobile builds each time (no incremental updates)
BETA: Clean builds from clean git state
PROD: Clean builds from clean git state

Build Artifacts:

Web: Fresh bundle created each deployment
iOS: Fresh IPA built from source (not incremental)
Android: Fresh AAB built from source (not incremental)

Why Immutable:

No "drift" between environments
Reproducible builds
Easy rollback (deploy previous build)
No accumulated cruft

4. Security is Paramount

Security is not an afterthought; it is a foundational requirement for all infrastructure and processes.

StackMap Security Measures:

Code Signing:

iOS: Fastlane match for certificates and profiles
Android: Keystore for app signing
Web: HTTPS for all deployments

Access Control:

QUAL/STAGE: Allows uncommitted changes (internal testing only)
BETA/PROD: Requires clean git state (release quality)
Production credentials restricted
Audit trail of all deployments

Secret Management:

API keys in environment variables (not hardcoded)
Certificates/keystores not in git
SSH keys for deployment access
Fastlane credentials encrypted

Quality Gates as Security:

Type checking catches unsafe code
Tests prevent regressions
Build validation ensures integrity
Clean git state enforces code review

StackMap Deployment Strategy

Four-Tier Deployment Flow

Developer → QUAL (test locally) → STAGE (internal validation) → BETA (closed beta) → PROD (public release)

Master Deployment Script

Always use the master script:

./scripts/deploy.sh [tier] [options]

The master script:

✅ Validates arguments and environment
✅ Enforces quality gates
✅ Manages deployment locking
✅ Delegates to tier-specific scripts
✅ Logs deployment actions
✅ Handles errors gracefully

Never directly execute tier scripts:

# ❌ WRONG - Bypasses validation
./scripts/deploy/qual_deploy.sh

# ✅ CORRECT - Uses master script
./scripts/deploy.sh qual --all

Deployment Commands

QUAL (Development Testing):

# All platforms (web + mobile)
./scripts/deploy.sh qual --all

# Individual platforms
./scripts/deploy.sh qual --web       # Web only to qual
./scripts/deploy.sh qual --ios       # iOS simulator only
./scripts/deploy.sh qual --android   # Android emulator only

# Combined platforms
./scripts/deploy.sh qual --android --ios  # Both mobile platforms

# iOS physical device
./scripts/deploy.sh qual --ios-device     # Deploy to connected device

STAGE (Internal Validation):

# All mobile platforms (recommended)
./scripts/deploy.sh stage --all

# Individual platforms (mobile only - no web)
./scripts/deploy.sh stage --ios      # iOS TestFlight (internal group)
./scripts/deploy.sh stage --android  # Android Play Internal Testing

BETA (Closed Beta Testing):

# All platforms (recommended)
./scripts/deploy.sh beta --all

# Individual platforms
./scripts/deploy.sh beta --web       # Beta web only
./scripts/deploy.sh beta --ios       # iOS TestFlight (beta group)
./scripts/deploy.sh beta --android   # Android Play Closed Testing

PROD (Public Release):

# All platforms (full production deploy)
./scripts/deploy.sh prod all

# Individual platforms
./scripts/deploy.sh prod web      # Production web only
./scripts/deploy.sh prod ios      # iOS App Store submission
./scripts/deploy.sh prod android  # Android Play Production

Deployment Workflow

Pre-Deployment:

Ensure all changes committed (for BETA/PROD)
Update PENDING_CHANGES.md with descriptive title and changes

Run local validation:

npm run typecheck  # Type checking
npm test           # Unit tests

Deployment Execution:

Run deployment command (master script)
Script enforces quality gates:
- Tests must pass
- Type checking must pass
- Build must succeed
- PENDING_CHANGES.md must exist
- Git must be clean (BETA/PROD only)
Script increments version (YYYY.MM.DD)
Script builds artifacts (web bundle, iOS IPA, Android AAB)
Script deploys to target tier
Script commits changes with message from PENDING_CHANGES.md

Post-Deployment:

Verify deployment success (check script output)
Test on target environment:
- QUAL: Test on simulators/emulators/devices
- STAGE: Internal team validates on physical devices
- BETA: Monitor beta tester feedback
- PROD: Monitor production metrics
Monitor for errors or regressions
Rollback if critical issues found

Quality Gates

Enforced by Deployment Scripts:

1. Tests Pass

npm test

All unit tests must pass
No skipped tests without approval
New tests required for new functionality
Regression tests for bug fixes

2. Type Checking Passes

npm run typecheck

No TypeScript errors
Type definitions complete
No any types without justification

3. Build Succeeds

# Web
npm run build

# iOS
xcodebuild (via Fastlane)

# Android
./gradlew (via Fastlane)

Web bundle builds successfully
iOS IPA builds successfully
Android AAB builds successfully
No compilation errors

4. PENDING_CHANGES.md Updated

File exists and has content
Used for commit message generation
Provides deployment documentation

5. Clean Git State (BETA/PROD)

No uncommitted changes
No untracked files
Working directory clean
Ensures all code reviewed

6. Version Increments

Version follows YYYY.MM.DD format
Increments from previous version
Synchronized across platforms

Platform-Specific Deployment

Web Deployment:

QUAL:

./scripts/deploy.sh qual --web

Builds web bundle: npm run build
Deploys to: stackmap.app/qual
Output directory: ROOT/qual/ (not web/build/)
API endpoint: qual-api.stackmap.app

BETA:

./scripts/deploy.sh beta --web

Builds web bundle: npm run build
Deploys to: stackmap.app/beta
Output directory: ROOT/beta/
API endpoint: beta-api.stackmap.app

PROD:

./scripts/deploy.sh prod web

Builds web bundle: npm run build
Deploys to: stackmap.app (root)
Output directory: ROOT/
API endpoint: api.stackmap.app

iOS Deployment:

QUAL:

./scripts/deploy.sh qual --ios

Builds for simulator: Debug configuration
Bundle ID: app.stackmap.qual
No TestFlight upload
Fast iteration (< 5 min)

iOS Physical Device (QUAL):

./scripts/deploy.sh qual --ios-device

Builds for physical device: Debug configuration
Bundle ID: app.stackmap.qual
Requires connected device
No TestFlight upload

STAGE:

./scripts/deploy.sh stage --ios

Builds Release configuration
Bundle ID: app.stackmap
Uploads to TestFlight (internal group)
API endpoint: qual-api.stackmap.app (qual DB)
Fastlane automation

BETA:

./scripts/deploy.sh beta --ios

Builds Release configuration
Bundle ID: app.stackmap
Uploads to TestFlight (beta group)
API endpoint: beta-api.stackmap.app (prod DB)
Fastlane automation
Requires clean git state

PROD:

./scripts/deploy.sh prod ios

Builds Release configuration
Bundle ID: app.stackmap
Uploads to App Store Connect
Prepares for App Store review submission
API endpoint: api.stackmap.app
Fastlane automation
Requires clean git state

Android Deployment:

QUAL:

./scripts/deploy.sh qual --android

Builds qualRelease variant
Package name: com.stackmapnative
No Play Console upload
Emulator/device testing
Build time: ~2-3 min (use 600000ms timeout)

STAGE:

./scripts/deploy.sh stage --android

Builds stageRelease variant
Package name: com.stackmapnative
Uploads to Play Console (Internal Testing)
API endpoint: qual-api.stackmap.app (qual DB)
Fastlane automation

BETA:

./scripts/deploy.sh beta --android

Builds betaRelease variant
Package name: com.stackmapnative
Uploads to Play Console (Internal/Closed Testing)
API endpoint: beta-api.stackmap.app (prod DB)
Fastlane automation
Requires clean git state

PROD:

./scripts/deploy.sh prod android

Builds prodRelease variant
Package name: com.stackmapnative
Uploads to Play Console (Production)
API endpoint: api.stackmap.app
Fastlane automation
Requires clean git state

Troubleshooting Common Issues

Issue: Tests Failing

Symptoms:

❌ Quality gate failed: Tests

Root Causes:

New code broke existing tests
Tests not updated for new functionality
Flaky tests (intermittent failures)
Environment-specific test failures

Resolution:

Run tests locally: npm test
Identify failing tests from output
Fix code or update tests
Re-run tests to verify fix
Commit fixes and retry deployment

Prevention:

Run tests before committing
Add tests for new functionality
Fix flaky tests immediately
Use watch mode during development: npm test -- --watch

Issue: Type Checking Errors

Symptoms:

❌ Quality gate failed: Type checking

Root Causes:

Missing type definitions
Incorrect type usage
any types without justification
Incomplete TypeScript migration

Resolution:

Run type checking locally: npm run typecheck
Fix type errors from output
Add type definitions if missing
Re-run type checking to verify
Commit fixes and retry deployment

Prevention:

Run type checking before committing
Use TypeScript for new files
Gradually migrate JavaScript to TypeScript
Add type definitions for imports

Issue: Build Failures

Symptoms:

❌ Quality gate failed: Build

Root Causes:

Syntax errors
Missing dependencies
Platform-specific build issues
Configuration errors

Resolution:

Web:

npm run build
# Check output for errors

iOS:

cd ios && pod install
xcodebuild -workspace StackMapNative.xcworkspace -scheme StackMapNative -configuration Release

Android:

cd android && ./gradlew clean
./gradlew assembleRelease

Prevention:

Test builds locally before deploying
Keep dependencies up to date
Follow platform-specific guidelines
Run clean builds periodically

Issue: PENDING_CHANGES.md Missing

Symptoms:

❌ Error: PENDING_CHANGES.md not found or empty

Root Cause:

Forgot to update PENDING_CHANGES.md before deployment

Resolution:

Create/update PENDING_CHANGES.md:

## Title: [Descriptive title]
### Changes Made:
- [Change 1]
- [Change 2]

Retry deployment

Prevention:

Always update PENDING_CHANGES.md first
Use as checklist before deployment
Include in pre-deployment workflow

Issue: Dirty Git State (BETA/PROD)

Symptoms:

❌ Error: Working directory not clean (BETA/PROD requires clean state)

Root Cause:

Uncommitted changes in working directory
Required for BETA/PROD (release quality)

Resolution:

Check git status: git status
Commit all changes: git add . && git commit -m "message"
Retry deployment

Alternative (QUAL/STAGE):

Deploy to QUAL or STAGE first (allows uncommitted changes)
Validate changes before cleaning up for BETA/PROD

Prevention:

Commit changes before BETA/PROD deployment
Use QUAL/STAGE for testing with uncommitted changes

Issue: iOS Build Timeout

Symptoms:

iOS build timed out after 300 seconds

Root Cause:

iOS builds can take 5-7 minutes
Default timeout too short

Resolution:

iOS builds use extended timeout automatically (600000ms)
If still timing out, check for:
- Xcode issues
- Provisioning profile problems
- Network issues (downloading dependencies)

Prevention:

iOS build timeouts already extended in scripts
Run cd ios && pod install if dependencies stale

Issue: Android Build Timeout

Symptoms:

Android build timed out after 120 seconds

Root Cause:

Android builds take 2-3 minutes
Default timeout too short

Resolution:

Android builds use extended timeout (600000ms / 10 min)
If still timing out, check for:
- Gradle issues
- Network issues (downloading dependencies)
- Build cache problems

Prevention:

Run cd android && ./gradlew clean periodically
Clear Gradle cache if persistent issues

Issue: Deployment to Wrong Tier

Symptoms:

Deployed to PROD instead of QUAL

Root Cause:

Incorrect tier argument to deploy script

Resolution:

Rollback immediately:

git log  # Find previous commit
git revert [commit-hash]
./scripts/deploy.sh prod all  # Deploy rollback

Deploy to correct tier

Prevention:

Double-check tier before deploying
Use QUAL/STAGE/BETA before PROD
Verify deployment command before executing

Issue: Version Increment Wrong

Symptoms:

Version is 2025.01.18 but expected 2025.01.19

Root Cause:

Version increment logic uses date
May be correct if deployed same day

Resolution:

Check current date: date +"%Y.%m.%d"
If date matches version, increment is correct
If date doesn't match, check version script logic

Prevention:

Version increments automatically (date-based)
Multiple deployments same day keep same version
Manual version override not recommended

Deployment Checklist

Use this checklist before every deployment:

Pre-Deployment

All changes committed (for BETA/PROD)
PENDING_CHANGES.md updated with descriptive title and changes
Tests pass locally: npm test
Type checking passes: npm run typecheck
Build succeeds locally (if possible)
Correct tier selected (QUAL/STAGE/BETA/PROD)
Correct platform flags (--all / --web / --ios / --android)

Deployment Execution

Using master script: ./scripts/deploy.sh [tier] [options]
Quality gates passed (tests, type checking, build)
Version incremented correctly
Deployment succeeded (no errors in output)

Post-Deployment

Deployment verified on target environment
Smoke test performed (basic functionality works)
No critical errors in logs
Rollback plan ready (if needed)

Tier-Specific Checks

QUAL:

Tested on simulators/emulators
Tested on physical devices (if needed)
API endpoint: qual-api.stackmap.app

STAGE:

Internal team notified
Tested on physical devices
Mobile-only (no web deployment)
API endpoint: qual-api.stackmap.app (qual DB)

BETA:

Clean git state verified
Beta testers notified (if needed)
Tested on all platforms
API endpoint: beta-api.stackmap.app (prod DB)

PROD:

Scripts and Tools

Master Deployment Script

Location: /scripts/deploy.sh

Usage:

./scripts/deploy.sh [tier] [options]

Tiers:
  qual      Deploy to QUAL (development testing)
  stage     Deploy to STAGE (internal validation)
  beta      Deploy to BETA (closed beta testing)
  prod      Deploy to PROD (public release)

Options:
  --all           Deploy all platforms (default)
  --web           Deploy web only
  --ios           Deploy iOS only
  --android       Deploy Android only
  --ios-device    Deploy iOS to physical device (QUAL only)

Examples:
  ./scripts/deploy.sh qual --all
  ./scripts/deploy.sh beta --ios --android
  ./scripts/deploy.sh prod web

What it does:

Validates arguments and environment
Checks quality gates (tests, type checking)
Manages deployment locking (prevents concurrent deploys)
Delegates to tier-specific script
Logs deployment actions
Handles errors and rollback

Tier-Specific Scripts

QUAL Script: /scripts/deploy/qual_deploy.sh

Rapid iteration, local testing
Allows uncommitted changes
Builds and deploys to QUAL environment
Web: stackmap.app/qual
Mobile: Simulators/emulators/devices

STAGE Script: /scripts/deploy/deploy_stage.sh

Internal validation before beta
Allows uncommitted changes
Mobile-only (no web deployment)
iOS TestFlight (internal group)
Android Play Internal Testing

BETA Script: /scripts/deploy/deploy_beta.sh

Closed beta testing
Requires clean git state
All platforms (web + mobile)
iOS TestFlight (beta group)
Android Play Closed Testing
Web: stackmap.app/beta

PROD Script: /scripts/deploy/prod_deploy.sh

Public production release
Requires clean git state
All platforms (web + mobile)
iOS App Store submission
Android Play Production
Web: stackmap.app (root)

Library Scripts

Location: /scripts/deploy/lib/

validation.sh - Pre-deployment validation

Check arguments
Verify environment
Validate git state

quality-gates.sh - Quality gate enforcement

Run tests
Run type checking
Validate build

reporting.sh - Deployment reporting

Generate deployment logs
Create status pages
Track metrics

ios-configure-variants.sh - iOS configuration

Configure .xcconfig files
Set bundle IDs
Manage build variants

Utility Scripts

Version Update: /scripts/update-mobile-versions.sh

Updates version across platforms
Synchronizes iOS, Android, web versions
Uses date-based format (YYYY.MM.DD)

App Configuration: /scripts/deploy/app-config.sh

Shared configuration for all deployment scripts
API endpoints
Version format
Build settings

Resources

See /atlas-skills/atlas-agent-devops/scripts/ for:

deploy-all.sh - Wrapper script for multi-tier deployments

Summary

The DevOps agent is responsible for:

✅ Managing CI/CD pipeline and deployment automation
✅ Enforcing quality gates (tests, type checking, build)
✅ Coordinating deployments across four tiers (QUAL/STAGE/BETA/PROD)
✅ Maintaining infrastructure and build tools
✅ Monitoring deployment health and optimizing performance
✅ Ensuring security and compliance at infrastructure level

Key success factors:

Automation: All deployments scripted and repeatable
Quality: Quality gates enforced, never bypassed
Safety: Clean git state for releases, rollback plan ready
Visibility: Deployment logs, metrics, monitoring

Remember: Use the master script (./scripts/deploy.sh) for all deployments. Never bypass quality gates for speed. Security and reliability are paramount.