The strongly.manifest.yaml File

The manifest file provides declarative configuration for building and deploying your application. It must be placed in your project root alongside the Dockerfile.

Basic Structure

# strongly.manifest.yaml (place in project root)
version: "1.0"
type: nodejs  # react, nodejs, flask, mcp_server, static, fullstack, custom
name: my-app
description: Brief description of your application
author: Your Name or Organization
tags:
  - api
  - backend

ports:
  - port: 3000
    name: http
    expose: true

env:
  - name: NODE_ENV
    value: "production"
    required: true

  - name: DATABASE_URL
    value: ""  # User must provide
    required: true
    secret: true  # Stored as Kubernetes Secret
    description: PostgreSQL connection string

health_check:
  path: /health
  initial_delay: 15
  period: 30

resources:
  cpu_request: "200m"
  memory_request: "512Mi"
  cpu_limit: "1000m"
  memory_limit: "1Gi"

Application Types

The type field determines default configuration and runtime behavior:

Type	Default Port	Use Case	Special Features
react	80	React/Vue SPA with client-side routing	Nginx-based serving, SPA fallback
nodejs	3000	Node.js APIs, Express, NestJS	Standard Node.js runtime
flask	5000	Python Flask/FastAPI applications	Python WSGI/ASGI support
static	80	Static HTML/CSS/JS sites	Nginx static file serving
fullstack	3000, 8000	Monorepo with frontend + backend	Multiple port exposure
mcp_server	8080	MCP protocol tool servers	MCP-specific configurations
custom	8080	Any other application type	No special defaults

Configuration Sections

Ports

Define which ports your application listens on:

ports:
  - port: 3000
    name: http
    expose: true  # Expose externally via ingress
  - port: 8080
    name: metrics
    expose: false  # Internal only

Fields:

• port: Port number (1-65535)
• name: Friendly name for the port
• expose: Whether to expose externally (default: true for first port)

Environment Variables

Define runtime configuration with proper metadata:

env:
  # Regular environment variable
  - name: API_URL
    value: "https://api.example.com"
    required: false
    description: Backend API endpoint

  # Secret (passwords, API keys, tokens)
  - name: API_KEY
    value: ""  # Must be provided by user
    required: true
    secret: true  # Encrypted in Kubernetes
    description: Third-party API key

  # Build-time variable
  - name: REACT_APP_VERSION
    value: "1.0.0"
    buildtime: true  # Passed as Docker build arg
    description: App version

Fields:

• name: Variable name (uppercase with underscores)
• value: Default value (can be empty for required vars)
• required: Whether variable must have a value (default: false)
• secret: Store as Kubernetes Secret (default: false)
• buildtime: Pass to Docker build as ARG (default: false)
• description: User-friendly description

Secrets Management

Variables marked as secret: true are stored in Kubernetes Secrets and encrypted at rest. Use this for passwords, API keys, and tokens.

React/Static App Configuration

For React and static applications, configure nginx serving:

type: react
static:
  root: /app/build
  index: index.html
  spa: true  # Fallback to index.html for client-side routing
  config_file: /app/build/config.js
  config_placeholder: __APP_CONFIG__

build:
  args:
    NODE_ENV: production
  output_dir: /app/build

Static Fields:

• root: Directory containing built static files
• index: Index file name (default: index.html)
• spa: Enable SPA routing fallback (default: true for react)
• config_file: Runtime config injection file path
• config_placeholder: Placeholder to replace with config

Health Checks

Your app must expose a health endpoint for Kubernetes liveness and readiness probes:

health_check:
  path: /health
  port: 3000
  initial_delay: 10  # Seconds before first check
  period: 30  # Check every 30 seconds
  timeout: 3
  failure_threshold: 3

Implementation Example (Express.js):

app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok' });
});

Implementation Example (Flask):

@app.route('/health')
def health():
    return {'status': 'ok'}, 200

Required Endpoint

Health checks are mandatory. If your app doesn't respond to health checks, Kubernetes will continuously restart it.

Resource Requirements

Set CPU and memory limits to ensure stable performance:

resources:
  cpu_request: "200m"  # 0.2 CPU cores
  memory_request: "512Mi"  # 512 MiB
  cpu_limit: "1000m"  # 1 CPU core
  memory_limit: "1Gi"  # 1 GiB

Recommended Resources by App Type:

App Type	CPU Request	Memory Request	CPU Limit	Memory Limit
React/Static	50m	128Mi	200m	256Mi
Node.js API	200m	512Mi	1000m	1Gi
Flask API	200m	512Mi	1000m	1Gi
Heavy Processing	500m	1Gi	2000m	2Gi

CPU Units

• 1000m = 1 CPU core
• 500m = 0.5 CPU cores
• 100m = 0.1 CPU cores

Runtime Configuration

Customize the container runtime:

runtime:
  command: ["node", "dist/server.js"]
  working_dir: /app
  health_check_path: /health

Fields:

• command: Override container CMD (array format)
• working_dir: Working directory (default: /app)
• health_check_path: Alternative to health_check.path

Proxy Configuration

Configure ingress proxy behavior:

proxy:
  websocket: true  # Enable WebSocket support
  timeout: 60  # Request timeout in seconds
  max_body_size: 10m  # Max request body size

Complete Examples

Node.js API

version: "1.0"
type: nodejs
name: user-api
description: REST API for user management
author: Acme Corp
tags: [nodejs, api, backend]

ports:
  - port: 3000
    name: http
    expose: true

env:
  - name: NODE_ENV
    value: "production"
    required: true

  - name: DATABASE_URL
    value: ""
    required: true
    secret: true
    description: PostgreSQL connection string

  - name: JWT_SECRET
    value: ""
    required: true
    secret: true
    description: Secret for JWT signing

runtime:
  command: ["node", "dist/server.js"]
  working_dir: /app
  health_check_path: /health

health_check:
  path: /health
  initial_delay: 15
  period: 30

proxy:
  websocket: true
  timeout: 60

resources:
  cpu_request: "200m"
  memory_request: "512Mi"
  cpu_limit: "1000m"
  memory_limit: "1Gi"

React SPA

version: "1.0"
type: react
name: admin-dashboard
description: Admin dashboard SPA
author: Acme Corp
tags: [react, frontend]

ports:
  - port: 80
    name: http
    expose: true

static:
  root: /app/build
  index: index.html
  spa: true
  config_file: /app/build/config.js
  config_placeholder: __APP_CONFIG__

build:
  args:
    NODE_ENV: production
    REACT_APP_VERSION: "1.0.0"
  output_dir: /app/build

env:
  - name: REACT_APP_API_URL
    value: "https://api.acme.com"
    buildtime: true
    description: Backend API endpoint

health_check:
  path: /
  initial_delay: 5
  period: 30

resources:
  cpu_request: "50m"
  memory_request: "128Mi"
  cpu_limit: "200m"
  memory_limit: "256Mi"

Flask API

version: "1.0"
type: flask
name: ml-api
description: Machine learning inference API
author: Data Team
tags: [python, flask, ml]

ports:
  - port: 5000
    name: http
    expose: true

env:
  - name: FLASK_ENV
    value: "production"
    required: true

  - name: MODEL_PATH
    value: "/app/models/model.pkl"
    description: Path to ML model file

  - name: REDIS_URL
    value: ""
    required: true
    secret: true
    description: Redis cache connection string

health_check:
  path: /health
  port: 5000
  initial_delay: 20
  period: 30
  timeout: 5

resources:
  cpu_request: "500m"
  memory_request: "1Gi"
  cpu_limit: "2000m"
  memory_limit: "2Gi"

Validation

The platform validates your manifest during deployment. Common errors:

• Missing required fields: version, type, name
• Invalid type: Must be one of the supported types
• Invalid port: Must be 1-65535
• Invalid resource format: Must use Kubernetes format (e.g., "500m", "1Gi")
• Secret without value: Required secrets need values (or user must provide)

Next Steps

• Deploy your application
• Configure environment variables
• Write your Dockerfile
• Use STRONGLY_SERVICES