Executive Summary

DeployMe is a proprietary cloud infrastructure-as-a-service (IaaS) platform that revolutionizes application deployment and lifecycle management. Unlike traditional cloud providers (AWS, Azure, Heroku), DeployMe offers a specialized, developer-first approach with intelligent automation, standardized workflows, and unprecedented operational simplicity.

Platform Overview

What is DeployMe?

DeployMe is an intelligent cloud deployment agent and infrastructure management platform that automates the entire application lifecycle—from code commit to production deployment, monitoring, and maintenance. Built with JavaScript, Express.js, and modern DevOps principles, DeployMe serves as a unified control plane for deploying and managing thousands of application instances across multiple environments.

Core Philosophy

Problem Statement

Modern organizations face a deployment paradox:

• Runtime Fragmentation: Different projects use different runtime versions (Java 8, 11, 17; Node 14, 16, 18), creating maintenance nightmares and unpredictable behavior
• Tool Proliferation: Separate tools for deployment, monitoring, logging, rollbacks, and management create operational overhead
• Configuration Complexity: AWS, Azure, and similar platforms require extensive configuration, IAM policies, networking setup, and infrastructure-as-code expertise
• Deployment Friction: Manual deployment steps, approval workflows, and complex CI/CD pipelines slow release cycles
• Visibility Gaps: Lack of unified visibility into application health, performance, and resource utilization

Business Value Proposition

Strategic Benefits

1. Accelerated Time-to-Market

Impact: Deploy 70x more frequently with 90%+ less time spent on deployment activities

• Before DeployMe: Hours to days per deployment, manual steps, coordination overhead
• After DeployMe: Minutes per deployment, fully automated, zero coordination required
• Business Outcome: Faster feature delivery, competitive advantage, increased customer satisfaction

2. Enhanced Developer Productivity

Impact: 50% more time for feature development instead of infrastructure management

• Eliminate context switching between deployment tools
• Self-service deployment for all team members
• No infrastructure expertise required
• Focus on code, not configuration

3. Cost Optimization

Impact: 90%+ reduction in total cost of ownership

TCO Analysis (Annual, 50 Applications)

Core Features & Capabilities

1. Multi-Application & Multi-Branch Deployment

Business Value: Dramatically reduce deployment coordination overhead and enable true continuous deployment.

Technical Implementation:

• Checkbox-based multi-selection interface for applications
• Branch filtering with environment-specific deployment rules
• Parallel deployment execution with dependency management
• "Deploy Selected" button triggers coordinated deployment across all selections

2. Global Service Control Operations

Feature: Execute operations on all services with single-button clicks for rapid system-wide management.

Available Operations:

3. Instance-Level Granular Control

Feature: Manage individual application instances with precision control and real-time operations.

4. Intelligent Build Artifact Rollback

Feature: Instant rollback to any of the last 7 successful builds with zero downtime.

• 7-Generation Retention: Last 7 successful builds kept per application
• Application-Level Granularity: Rollback specific apps without affecting others
• Branch-Specific Rollback: Rollback production without touching development
• Artifact Version Selection: Choose exact build version to rollback to
• Zero-Downtime Execution: Rolling rollback with health checks
• 30-60 Second Rollback Time: 90%+ reduction in MTTR

5. Extensive Search, Filter & Monitoring

Filter Dimensions:

• Sort by Name: Alphabetical sorting (A-Z, Z-A)
• Filter By App Name: See all instances of an application either app or cron instances
• Branch Filter: Filter by deployment environment (production, development, stage, test, ai, main)
• Sort by Memory: Memory usage sorting (DESC, ASC) for resource optimization
• Sort by CPU: CPU usage sorting to identify performance issues
• Status Filter: Filter by instance status (online, stopped, errored, starting)
• Real-Time Search: Text search across all fields (PID, Name, Branch, Status)

Monitoring Table Columns:

6. Flexible Branch & Environment Strategy

Feature: Support for both standard Git workflows and custom branch strategies.

Standard Branches (Default for most applications):

• production: Production environment, highest stability
• stage: Pre-production testing, staging environment
• development: Active development, latest changes

Irregular Branches (For non-standard workflows):

• test: Dedicated testing environment, routes to stage deployment
• ai: AI/ML experimentation branch, routes to stage deployment
• main: Single-instance deployment for tools not following standard workflow

Technical Architecture

System Architecture Diagram

Component Details

1. Web UI Layer (Pug + JavaScript)

Purpose: Interactive management console for all platform operations

• Real-time instance monitoring table
• Multi-select deployment interface
• Rollback artifact selector
• Global service control buttons
• Advanced search and filtering
• Live log streaming
• Environment variable editor

2. Service Manager (PM2 Integration)

Purpose: Manages application process lifecycle using PM2

• Process spawning and monitoring
• Automatic restart on crashes
• Resource limit enforcement
• Log aggregation and rotation
• Cluster mode for multi-instance apps
• Zero-downtime reloads

3. NGINX Load Balancer

Purpose: Automatic load balancing and traffic routing

Auto-Configuration Example:

upstream plat_authorizers_svc {
    server 127.0.0.1:3001;  # instance-1
    server 127.0.0.1:3002;  # instance-2
    server 127.0.0.1:3003;  # instance-3
}

server {
    listen 80;
    server_name api.yourdomain.com;

    location /authorizers {
        proxy_pass http://plat_authorizers_svc;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        
        # Health check
        proxy_next_upstream error timeout http_500;
    }
}

Configuration Management System

Dual Configuration Architecture

DeployMe uses a two-tier configuration system that separates platform-level standardization from application-level customization.

Configuration Server 1: platform-setup/app.json

Full Configuration Schema:

{
  "{github-repo-name}": {
    "appName": "string",                    // Deployed app name prefix
    "branchCheck": boolean,                 // Enable/disable branch validation
    "isMultipleBranchAllowed": boolean,     // Allow concurrent branch deployments
    "isCustomPortEnabled": boolean,        // Allow manual port declaration use case
    "PORT": number,                        // When isCustomPortEnabled is true only
    "isAllowedTestApp": boolean,            // Enable 'test' branch (→ stage)
    "isAllowedAiApp": boolean,              // Enable 'ai' branch (→ stage)
    "instances": [
      {
        "extendEnvName": "agent-system",    // Mono Repo use case where one repo serves multiple apps
        "extendAppName": "agent-system",    // Mono Repo use case where one repo serves multiple apps
        "type": "app" | "cron",             // Instance type
        "buildCommand": "string" | "USE_DEFAULT_COMMAND",
        "startCommand": "string" | "USE_DEFAULT_COMMAND",
        "concurrency": {                     // Only for type: "app"
          "production": number,              // Number of replicas
          "stage": number,
          "development": number
        },
      }
    ]
  }
}

Complete Example:

{
  "sabi-authorizer": {
    "appName": "plat-authorizers-svc",
    "branchCheck": true,
    "isMultipleBranchAllowed": true,
    "isAllowedTestApp": true,
    "isAllowedAiApp": true,
    "instances": [
      {
        "type": "app",
        "extendEnvName": "authorizer-engine",
        "extendAppName": "authorizer-engine-01",
        "buildCommand": "USE_DEFAULT_COMMAND",
        "startCommand": "USE_DEFAULT_COMMAND",
        "concurrency": {
          "production": 4,
          "stage": 2,
          "development": 1
        }
      },
     {
        "type": "app",
        "extendEnvName": "authorizer-app",
        "extendAppName": "authorizer-app-01",
        "buildCommand": "USE_DEFAULT_COMMAND",
        "startCommand": "USE_DEFAULT_COMMAND",
        "concurrency": {
          "production": 4,
          "stage": 2,
          "development": 1
        }
      },
      {
        "type": "cron",
        "buildCommand": "USE_DEFAULT_COMMAND",
        "startCommand": "npm run cron:cleanup"
      }
    ]
  },
  "sabi-backup-retention-system": {
    "appName": "plat-backup-retention-svc",
    "branchCheck": true,
    "isMultipleBranchAllowed": false,
    "isAllowedTestApp": false,
    "isAllowedAiApp": false,
    "instances": [
      {
        "type": "app",
        "buildCommand": "mvn clean package",
        "startCommand": "java -jar target/app.jar",
        "concurrency": {
          "production": 3,
          "stage": 1,
          "development": 1
        }
      }
    ]
  }
}

Configuration Keys Explained:

Configuration Server 2: platform-environments

Directory Structure:

platform-environments/
├── production/
│   ├── sabi-authorizer.env
│   ├── sabi-backup-retention-system.env
│   ├── data-exchange-service.env
│   └── ... (all other apps)
├── stage/
│   ├── sabi-authorizer.env
│   └── ...
├── development/
│   ├── sabi-authorizer.env
│   └── ...
├── test/ (routes to stage deployment)
│   └── ...
├── ai/ (routes to stage deployment)
│   └── ...
└── main/ (single instance deployments)
    └── ...

Environment File Example (production/sabi-authorizer.env):

# Database Configuration
DATABASE_URL=postgresql://user:[email protected]:5432/authorizers
DATABASE_POOL_SIZE=20
DATABASE_SSL=true

# Redis Configuration
REDIS_URL=redis://prod-redis.example.com:6379
REDIS_PASSWORD=

# Application Configuration
NODE_ENV=production
PORT=3000
LOG_LEVEL=info
MAX_REQUEST_SIZE=10mb

# External Services
AUTH_SERVICE_URL=https://auth.example.com
NOTIFICATION_SERVICE_URL=https://notifications.example.com

# Feature Flags
ENABLE_NEW_AUTH_FLOW=true
ENABLE_RATE_LIMITING=true

# Monitoring
SENTRY_DSN=https://[email protected]/project
NEW_RELIC_KEY=

Default Command Resolution

When USE_DEFAULT_COMMAND is specified, DeployMe uses language-specific defaults:

Deployment Workflows

Automated Deployment Process

Step-by-Step Flow:

Rollback Workflow

1. User Initiates Rollback: Navigate to "Rollback Builds" panel, select application, branch, and target build version from last 7 builds
2. Retrieve Backup Artifact: Fetch selected backup artifact from storage and verify integrity
3. Stop Current Instances (Rolling): Remove from NGINX upstream pool, wait for connection draining, gracefully stop instances while keeping N-1 running
4. Deploy Backup Version: Deploy backup artifact to instances with same instance count
5. Health Check Verification: Execute health checks on rolled-back instances
6. Update Load Balancer: Update NGINX configuration and add instances back to upstream pool
7. Rollback Complete: Update UI status, create new backup of previous version

Management Console Features

System Statistics Dashboard

Application Instance Table

Example Instance Entry:

Instance-Level Actions

Available via Action Dropdown:

• Start Start stopped instance
• Restart Restart running instance
• Reload Hot reload configuration
• Stop Gracefully stop instance
• Redeploy Redeploy with latest code
• View Metrics Open real-time metrics dashboard
• View Logs Stream live application logs
• View/Edit Env Manage environment variables
• Deploy Env Changes Push env changes to config server

Live Environment Variable Management

Management Interface

Comparative Analysis: DeployMe vs Traditional Cloud

Feature Comparison Matrix

When to Choose Each Platform

Getting Started Guide

Prerequisites

• GitHub organization account
• Git repositories with application code
• Basic understanding of your application's runtime requirements
• Administrative access to configure webhooks

Step-by-Step Setup

Step 1: Platform Configuration (15 minutes)

1.1 Create platform-setup/app.json

{
  "your-first-app": {
    "appName": "plat-first-app-svc",
    "branchCheck": true,
    "isMultipleBranchAllowed": true,
    "isAllowedTestApp": true,
    "isAllowedAiApp": true,
    "instances": [
      {
        "type": "app",
        "buildCommand": "USE_DEFAULT_COMMAND",
        "startCommand": "USE_DEFAULT_COMMAND",
        "concurrency": {
          "production": 3,
          "stage": 2,
          "development": 1
        }
      }
    ]
  }
}

1.2 Create platform-environments structure

# Create directory structure
mkdir -p platform-environments/{production,stage,development,test,ai,main}

# Create environment files for your app
touch platform-environments/production/your-first-app.env
touch platform-environments/stage/your-first-app.env
touch platform-environments/development/your-first-app.env

1.3 Populate environment files

# platform-environments/production/your-first-app.env
NODE_ENV=production
PORT=3000
DATABASE_URL=postgresql://prod-db.example.com/myapp
REDIS_URL=redis://prod-redis.example.com:6379
LOG_LEVEL=info

Step 2: GitHub Webhook Configuration (5 minutes)

1. Navigate to your GitHub repository
2. Click "Settings" tab → "Webhooks" → "Add webhook"
3. Configure:
   • Payload URL: https://deployme.yourdomain.com/api/webhook
   • Content type: application/json
   • Secret: (provided by DeployMe admin)
   • Events: Just the push event
   • Active: Checked
4. Click "Add webhook" and verify 200 OK response

Step 3: First Deployment (5 minutes)

git add .
git commit -m "Initial deployment"
git push origin development

Best Practices

Application Configuration

// Node.js example
app.get('/health', (req, res) => {
  res.status(200).json({
    status: 'healthy',
    timestamp: new Date().toISOString(),
    version: process.env.APP_VERSION
  });
});

// ❌ BAD - Hardcoded
const dbUrl = 'postgresql://prod-db.example.com/myapp';

// ✅ GOOD - Environment variables
const dbUrl = process.env.DATABASE_URL;

// package.json
{
  "scripts": {
    "build": "npm run build:cache",
    "build:cache": "npm ci --prefer-offline"
  }
}

// app.json
{
  "concurrency": {
    "production": 4,  // 4 × 1GB = 4GB
    "stage": 2,       // 2 × 1GB = 2GB
    "development": 1  // 1 × 512MB
  }
}

Deployment Strategy

• Use Branch Protection: Require pull request reviews for production/main branches
• Monitor First Deployments: Watch metrics closely for the first 10 minutes after deployment
• Implement Gradual Rollouts: Deploy to dev (Day 1) → stage (Day 3) → production (Day 5)
• Test Rollback Procedures: Practice rollback quarterly to ensure team readiness

Monitoring & Maintenance

Set Up Alerting Thresholds

Regular Maintenance Tasks

• Daily: Check production error logs
• Weekly: Review all application logs, analyze performance trends
• Monthly: Review resource utilization, optimize configurations
• Quarterly: Test rollback procedures, security audit, dependency updates

Security Best Practices

Credential Rotation Schedule

• GitHub tokens: Every 90 days
• API keys: Every 90 days
• Database passwords: Every 180 days
• SSL certificates: Automatic renewal (Let's Encrypt)

Never Commit Secrets

# .gitignore
.env
.env.local
*.key
*.pem
secrets/
config/production.json

Roadmap & Future Enhancements

Q1 2026: Enhanced Language Support

• ✅ Full Python deployment workflows (Django, Flask, FastAPI)
• ✅ Complete .NET Core support (.NET 6, 7, 8)
• ✅ Advanced dependency management (Poetry, NuGet)
• ✅ Virtual environment isolation
• ✅ Language-specific optimization profiles

Q2 2026: Advanced Deployment Strategies

• ✅ Canary deployments (gradual traffic shifting)
• ✅ Blue-green deployment strategy
• ✅ A/B testing support with traffic splitting
• ✅ Feature flag integration
• ✅ Custom deployment hooks (pre/post deployment scripts)

Q3 2026: Enhanced Monitoring & Analytics

• ✅ Advanced APM (Application Performance Monitoring)
• ✅ Distributed tracing integration
• ✅ Custom dashboard builder
• ✅ Performance analytics and insights
• ✅ Cost optimization recommendations
• ✅ Predictive scaling based on ML models

Q4 2026: Enterprise Features

• ✅ Multi-region deployment support
• ✅ Advanced RBAC with SSO (SAML, OAuth)
• ✅ Compliance reporting (SOC 2, GDPR, HIPAA)
• ✅ Disaster recovery automation
• ✅ Multi-tenancy support
• ✅ Enterprise support SLA (99.99% uptime)

2027: Ecosystem Expansion

Support & Resources

Documentation

• Platform Documentation: https://[email protected]/apps/documentation
• API Reference: support.sabi.am

Support Tiers

Contact Information

Conclusion

DeployMe represents a paradigm shift in cloud infrastructure management, moving away from the complexity and overhead of traditional cloud platforms toward a developer-first, automation-centric approach.

Why DeployMe Succeeds

Appendix

Glossary

Naming Conventions

API Reference (Preview)

# Deploy Application
POST /api/deploy
{
  "applications": ["sabi-authorizer", "data-exchange-service"],
  "branch": "production"
}

# Rollback Application
POST /api/rollback
{
  "application": "sabi-authorizer",
  "branch": "production",
  "artifactVersion": "v1.2.3-20250927"
}

# Get Instances
GET /api/instances?branch=production&status=online

# Update Environment
PUT /api/env/4157352
{
  "LOG_LEVEL": "debug",
  "ENABLE_FEATURE_X": "true"
}