Skip to main content

​
What It Does

Your services need to talk to each other. Your API needs database credentials. Your frontend needs the API URL. Your workers need message queue configuration. Monk figures all of this out automatically during code analysis and generates the complete configuration for your entire application. Connection strings, environment variables, secrets - all derived and wired automatically. No .env files to manage. No connection string debugging.

​
How It Works

​
Automatic Configuration Generation

Based on code analysis, Monk computes all necessary configuration values: What Monk discovers:
  • Environment variables your code references (DATABASE_URL, API_KEY, etc.)
  • Services that need to connect (API → Database, Worker → Redis)
  • External APIs your application calls
  • Port numbers and endpoints
  • Secret values that need protection
What Monk generates:
  • Database connection strings (postgresql://user:pass@host:5432/db)
  • Service URLs (https://api.yourapp.com)
  • API endpoints between services (http://api-service:3000/graphql)
  • Credentials for databases and services
  • All environment variables needed by your code
Monk always provides advice and asks for clarification when needed.

​
Dynamic Service Discovery

You don’t need to know database hostnames, internal IPs, or port numbers. Monk uses built-in service discovery to dynamically derive values: Discovery automatically provides:
  • Database connection strings - Generated from database host, port, credentials
  • Service endpoints - Internal URLs for service-to-service communication
  • Load balancer URLs - Public endpoints for external access
  • Network addresses - Container IPs and DNS names
When you scale from 1 to 5 API servers, all 5 get the correct configuration automatically. No manual updates needed.

​
Intelligent Connection Mapping

Monk understands how your components connect and configures discovery mechanisms accordingly: Network connections:
  • API server → Database (TCP connection, credentials needed)
  • Worker → Message queue (pub/sub, connection string needed)
  • Services within application (internal DNS, no auth needed)
Callback connections:
  • Webhook URLs for external services (Stripe, GitHub, etc.)
  • OAuth redirect URLs
  • API callback endpoints
Browser-server connections:
  • Frontend → API (public URL, CORS configuration)
  • Static assets → CDN (public URLs)
Monk configures each appropriately:
  • Internal services use private DNS and encrypted tunnels
  • Public endpoints get load balancer URLs
  • Callbacks receive publicly accessible URLs
  • CORS configured for frontend-backend communication

​
Automatic Secret Detection

Monk knows which values should be secrets and treats them (and values derived from them) securely: Automatically identified as secrets:
  • Database passwords
  • API keys (Stripe, OpenAI, AWS credentials, etc.)
  • JWT signing keys
  • OAuth client secrets
  • Encryption keys
Secret storage:
  • Stored in built-in secret storage (see Security)
  • Never exposed in configuration files
  • Injected securely at runtime
  • Rotatable without code changes

​
Reconfiguration at Any Time

Don’t need to get configuration perfect upfront. Ask Monk to reconfigure at any point: Change examples: 
You: Change the database connection pool size to 20

You: Add FEATURE_FLAG_NEW_UI to the frontend
Configuration changes are applied with zero downtime after deployment.

​
Review & Modify Full Configuration

You can review the full configuration file and ask Monk to modify any part of it.

​
What You Need to Provide

Monk derives most configuration automatically, but you’ll need to provide values it can’t discover: External API keys:
  • Stripe, OpenAI, SendGrid, Twilio, etc.
  • Monk will ask for these when it finds references in your code
Custom configuration:
  • Feature flags
  • Business logic constants
  • Non-standard environment variables
Domain names:
  • Your custom domain (if not inferring from code)
  • Email sending domain
That’s it. Everything else - connection strings, credentials, service URLs - Monk generates.

​
What Makes This Different

Traditional configuration management requires:
  • Writing .env files for each environment
  • Manually creating connection strings
  • Managing secrets across multiple services
  • Debugging connection issues (“why can’t service A reach service B?”)
  • Updating configs when adding instances
  • Keeping configs in sync across services
  • Using tools like HashiCorp Vault, AWS Secrets Manager
  • Writing service discovery logic
With Monk: Configuration and wiring generated automatically from code. Services discover each other dynamically.

​
Key Capabilities

  • Automatic discovery - Finds all required environment variables from code
  • Dynamic service discovery - Connection strings and URLs generated automatically
  • Intelligent connection mapping - Understands how services connect
  • Secret detection - Automatically identifies and protects sensitive values
  • Built-in secret storage - Secure secret management included
  • Reconfiguration anytime - Change config after deployment without downtime
  • Unified configuration view - Review entire config as single YAML
  • Minimal user input - Only provide external API keys and custom values
  • Graceful scaling - New instances get correct config automatically
  • Zero-downtime updates - Config changes applied without interruption