Skip to main content

​
What It Does

Monk autonomously analyzes your codebase to understand what your application does, how it’s structured, and what it needs to run. This deep comprehension enables Monk to deploy your application without you writing any configuration files or documentation. Whether you have a single service or a complex monorepo, any language or framework, with or without existing Docker/Kubernetes configs - Monk figures it out.

​
How It Works

​
When Code Analysis Happens

Monk automatically analyzes your code:
  • During deployment - Whenever you ask Monk to deploy your project
  • When changes are detected - When you add a new service, change databases, or modify architecture
  • On demand - Chat with Monk and say build my project to trigger analysis without deploying
Tip: Use build my project when you want to see how Monk understands your application without proceeding to deployment. Useful for verifying the configuration Monk generates.

​
Intelligent Code Inspection

When analysis runs, Monk doesn’t read all your source code line by line. Instead, it intelligently looks for specific indicators to understand your application: What Monk looks for:
  • Entry points - main.py, index.js, server.go, application start files
  • Environment variable references - process.env.DATABASE_URL, os.getenv(), config loading
  • Libraries and dependencies - package.json, requirements.txt, go.mod, Gemfile
  • Endpoints exposed - API routes, port bindings, server configurations
  • Database connections - ORM configurations, database client initialization
  • Third-party integrations - API clients, SDK usage, service connections
Purpose: Understand what your code does, its role in the system, what connections it expects, and what values it needs to function.

​
Leveraging Existing Configuration

Monk will also read any existing configuration to gain additional understanding:
  • READMEs - Setup instructions, architecture notes
  • Docker Compose files - Service definitions and relationships
  • Helm charts - Kubernetes configurations
  • Terraform files - Infrastructure requirements
  • CI/CD configs - Build and deployment steps
Important: Monk uses these files to better understand your application, but doesn’t require them. You can give Monk raw code with no configuration files, and it will figure everything out.

​
Example: What Monk Sees

Here’s what Monk would analyze in a typical Node.js + React application: 
my-ecommerce-app/
├── frontend/
│   ├── package.json           # Monk sees: React dependencies, build scripts
│   ├── src/
│   │   ├── index.tsx         # Entry point for frontend
│   │   └── api/
│   │       └── client.ts     # Monk sees: API_URL environment variable needed
│   └── .env.example          # Monk reads: Expected environment variables
│
├── backend/
│   ├── package.json           # Monk sees: Express, pg (PostgreSQL client), Stripe SDK
│   ├── server.js             # Entry point, PORT binding (3000)
│   ├── routes/
│   │   ├── api.js            # Monk sees: REST endpoints exposed
│   │   └── payments.js       # Monk sees: Stripe integration needs STRIPE_SECRET_KEY
│   └── db/
│       └── connection.js     # Monk sees: PostgreSQL connection string needed
│
├── docker-compose.yml         # Monk reads: Service structure, postgres:14
└── README.md                  # Monk reads: "Run npm install, then npm start"
From this, Monk understands:
  • Frontend: React SPA that needs to connect to an API → Deploy to Netlify/Vercel
  • Backend: Express API on port 3000, needs PostgreSQL and Stripe → Containerize and deploy to cloud
  • Database: PostgreSQL required → Provision managed instance or self-host
  • Configuration needed: API_URL, DATABASE_URL, STRIPE_SECRET_KEY
  • Build process: npm install then npm start for both services

​
What Monk Does With This Knowledge

With this understanding, Monk can autonomously:
  1. Configure and wire services - Generate all environment variables and connection strings
  2. Containerize your application - Create optimized Docker containers tailored to your app
  3. Set up build & CI/CD - Create build pipelines that match your application’s needs
  4. Deploy everything - Place each component on the optimal platform

​
Privacy & Security

Your code during analysis: Code pieces are sent to Monk servers for analysis but are not stored and we’re not training on them. The code is examined solely to infer deployment details. See Security for full details on how your code and credentials are protected.

​
Key Capabilities

  • Universal language support - Any programming language or framework
  • Automatic component detection - Frontends, backends, workers, databases, APIs
  • Dependency analysis - Package managers, libraries, SDKs
  • Environment variable discovery - All configuration requirements identified
  • Service relationship mapping - How components connect to each other
  • Database schema inference - Understanding data layer requirements
  • API endpoint discovery - Internal and external APIs detected
  • Existing config leverage - Uses Docker Compose, Helm, Terraform if present
  • Lambda handler detection - Serverless functions identified automatically

​
What Makes This Different

Traditional deployment requires:
  • Writing documentation about your architecture
  • Maintaining configuration files in sync with code
  • Documenting all environment variables needed
  • Explaining service relationships and dependencies
With Monk: Your code is your documentation. Monk reads and understands it automatically.