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 config. Monk figures this out during code analysis and generates the complete configuration for your entire application. Connection strings, environment variables, secrets — all derived and wired automatically.

​
How It Works

​
Automatic Configuration Generation

Based on code analysis, Monk computes every configuration value you need. What Monk discovers:
  • Environment variables your code references (DATABASE_URL, API_KEY, etc.)
  • Services that need to connect (API to Database, Worker to 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 your code expects
Monk asks for clarification when it needs your input.

​
Dynamic Service Discovery

You don’t need to know database hostnames, internal IPs, or port numbers. Monk uses built-in service discovery to derive values dynamically:
  • Database connection strings — Generated from database host, port, and 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
Scale from 1 to 5 API servers. All 5 get the correct configuration automatically.

​
Intelligent Connection Mapping

Monk understands how your components connect and configures discovery accordingly. Network connections:
  • API server to Database (TCP, credentials needed)
  • Worker to 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 to API (public URL, CORS configuration)
  • Static assets to CDN (public URLs)
Monk configures each type appropriately. Internal services use private DNS and encrypted tunnels. Public endpoints get load balancer URLs. Callbacks receive publicly accessible URLs. CORS is configured for frontend-backend communication.

​
Automatic Secret Detection

Monk knows which values are secrets and treats them — and anything 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 handling:
  • Stored in built-in secret storage
  • Never exposed in configuration files
  • Injected securely at runtime
  • Rotatable without code changes

​
Reconfiguration at Any Time

You don’t need to get configuration right upfront. Tell Monk to reconfigure whenever you want: 
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. You provide only what it can’t discover: External API keys:
  • Stripe, OpenAI, SendGrid, Twilio, etc.
  • Monk asks 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 inferred from code)
  • Email sending domain
That’s it. Connection strings, credentials, service URLs — Monk generates all of it.

Code Analysis

How Monk discovers your configuration requirements from source code.

Security

How secrets are stored, injected, and protected at runtime.