# AI Integration Source: https://docs.cnap.tech/ai-integration Integrate CNAP with AI assistants and LLM providers through our built-in MCP server and contextual menu features Get instant, accurate answers about CNAP directly from your favorite AI tools. Our documentation is automatically optimized for AI assistants with zero configuration required. Connect to AI tools through built-in MCP servers, contextual menus, and llms.txt files. ## Quick Start Click the contextual menu button (usually in the top-right corner) on any documentation page. Select **Connect to Cursor** or **Connect to VS Code** for automatic installation. Your AI tool now has access to CNAP documentation. Try asking: "How do I create a new product in CNAP?" ## Built-in Features ### MCP Server An MCP server enables AI tools to search and interact with CNAP documentation in real-time. Available at `https://docs.cnap.tech/mcp` - no configuration needed. ### Contextual Menu Quick actions available on every page: * **Copy page**: Copy as Markdown for AI tools * **View as Markdown**: Open page as Markdown * **Open in ChatGPT**: Create conversation with current page * **Open in Claude**: Create conversation with current page * **Open in Perplexity**: Create conversation with current page * **Copy MCP server URL**: Copy URL to clipboard * **Connect to Cursor**: Auto-install MCP server * **Connect to VS Code**: Auto-install MCP server ### LLMs.txt Files Industry-standard files for efficient AI indexing: * [**llms.txt**](https://docs.cnap.tech/llms.txt): All pages with descriptions * [**llms-full.txt**](https://docs.cnap.tech/llms-full.txt): Complete documentation in one file ## Manual Configuration **Configuration File Location:** * macOS: `~/Library/Application Support/Claude/claude_desktop_config.json` * Windows: `%APPDATA%\Claude\claude_desktop_config.json` * Linux: `~/.config/claude/claude_desktop_config.json` ```json claude_desktop_config.json theme={null} { "mcpServers": { "cnap": { "command": "/Users/robin/.volta/bin/pnpm", "args": ["dlx", "mcp-remote", "https://docs.cnap.tech/mcp"], "env": {} } } } ``` We recommend pnpm for better caching and performance. The full path ensures compatibility across systems. For Claude's web interface: Navigate to [Claude Settings](https://claude.ai/settings/connectors) → **Add custom connector** * **Name**: `CNAP` * **URL**: `https://docs.cnap.tech/mcp` Click attachments button (plus icon) → Select CNAP → Ask questions Add via command line: ```bash theme={null} claude mcp add --transport http cnap https://docs.cnap.tech/mcp ``` Verify connection: ```bash theme={null} claude mcp list ``` Claude Code CLI is ideal for development workflows. **Command Palette:** 1. Press `Cmd+Shift+P` (Mac) or `Ctrl+Shift+P` (Windows/Linux) 2. Search "Open MCP settings" 3. Select **Add custom MCP** ```json mcp.json theme={null} { "mcpServers": { "cnap": { "url": "https://docs.cnap.tech/mcp" } } } ``` Create `.vscode/mcp.json`: ```json .vscode/mcp.json theme={null} { "servers": { "cnap": { "type": "http", "url": "https://docs.cnap.tech/mcp" } } } ``` Requires MCP extension from VS Code marketplace. ```json goose_config.json theme={null} { "mcpServers": { "cnap": { "url": "https://docs.cnap.tech/mcp" } } } ``` Configuration may vary based on your Goose setup. ## Example Questions Ask your AI assistant about CNAP: * "How do I create a new product in CNAP?" * "What are the requirements for importing a cluster?" * "How does the payment system work?" * "What's the difference between managed and imported clusters?" * "How do I set up pricing for my products?" The MCP server provides real-time data for accurate, up-to-date answers. ## Benefits * **Zero Configuration**: Automatic setup through contextual menu * **Always Current**: Real-time data from latest documentation * **Context-Aware**: AI understands your specific CNAP setup * **Comprehensive**: Access to all docs, APIs, and guides * **Fast**: Instant answers without manual searching ## Troubleshooting * Verify URL: `https://docs.cnap.tech/mcp` * Check internet connection * Ensure AI tool supports MCP protocol * Try contextual menu for automatic setup * Check JSON syntax in config files * Verify file permissions * Confirm correct file location * Restart your AI application * MCP server provides real-time data * Restart MCP connection * Clear cached responses in AI app * Verify correct MCP server URL ### Need Help? 1. **Automatic Setup**: Use contextual menu first 2. **Check Logs**: Review MCP connection logs 3. **Test Connection**: Access `https://docs.cnap.tech/mcp` directly 4. **Community**: Join our [Discord](https://cnap.tech/discord) 5. **Advanced**: See [MCP specification](https://modelcontextprotocol.io) ## Advanced ### Markdown Access Access any page as Markdown by appending `.md`: * Example: `https://docs.cnap.tech/ai-integration.md` ### LLMs.txt Files * **llms.txt**: `https://docs.cnap.tech/llms.txt` * **llms-full.txt**: `https://docs.cnap.tech/llms-full.txt` These help AI tools understand documentation structure and find relevant content. ## Coming Soon: API Integration Direct API integration for AI agents will enable: * **Automated Deployments**: Deploy via AI commands * **Cluster Management**: Manage infrastructure with natural language * **Intelligent Monitoring**: AI-powered insights * **Custom Workflows**: Build AI-driven automation ### Planned Features * Natural language interface: "Deploy my product to US-East" * AI-driven resource optimization * Automated troubleshooting assistance * Custom AI agents for CNAP workflows API integration coming in a future release. Subscribe for updates. *** *Use AI assistants to interact with CNAP through natural language, making cloud infrastructure management simpler.* # Introduction Source: https://docs.cnap.tech/apis/introduction Welcome to the API documentation for CNAP. ## Welcome This is the place for developers to learn how to build on top of CNAP's strong foundation to create new experiences for users, developers, and providers. We are currently working on this documentation and will update it soon. It will support the OpenAPI RESTful API, gRPC, gRPC-Web, and ConnectRPC protocols with generated client libraries in multiple languages. There will also be a playground studio for testing and exploring the API. # Application Sources Source: https://docs.cnap.tech/app-sources Choose how to deploy your application with Helm Charts, GitHub repositories, or Docker images CNAP supports three flexible ways to deploy your applications as products. Each method is designed for different use cases and deployment scenarios. ## Source Types Browse thousands of ready-to-deploy applications from Artifact Hub Auto-build from source code using Nixpacks Deploy pre-built container images ## Helm Charts Deploy battle-tested applications from the vast Helm ecosystem via [Artifact Hub](https://artifacthub.io). ### Benefits * **Production-ready** - Pre-configured applications maintained by the community * **Rich ecosystem** - Thousands of applications for databases, web servers, monitoring tools, and more * **Customizable** - Configure applications using Helm values * **Verified publishers** - Many charts come from trusted, verified sources ### Best For * Standard software stacks (PostgreSQL, Redis, NGINX, WordPress, Grafana, etc.) * Enterprise applications with complex configurations * Applications requiring sophisticated Kubernetes deployments * Teams leveraging existing Helm knowledge ### How It Works 1. Search Artifact Hub directly in the product creation flow 2. Select from popular applications or search for specific packages 3. CNAP automatically handles Helm chart deployment to your clusters 4. Configure pricing and make it available to customers Look for charts with verified publisher badges for added reliability and security. ## GitHub Repositories Deploy applications directly from your GitHub repositories with automatic builds using Nixpacks. Connect your GitHub accounts and organizations for seamless access to your repositories. ### Benefits * **Source-to-deployment** - Push code, get containerized applications * **Auto-detection** - Nixpacks automatically detects your language and framework * **No Dockerfile needed** - Smart defaults for Node.js, Python, Go, Ruby, and more * **CI/CD friendly** - Integrates with your development workflow * **Secure Authentication** - GitHub App provides secure access without personal tokens * **Team Collaboration** - Share repository access across workspace members ### Best For * Custom applications and APIs * Rapid development and iteration * Modern web frameworks (Next.js, SvelteKit, FastAPI, Django, etc.) * Monorepos and microservices * Team projects and organization repositories ### How It Works 1. **Connect GitHub Account** - Install the CNAP GitHub App to your account or organization 2. **Select Repositories** - Choose which repositories to make available to your workspace 3. **Auto-Build** - Nixpacks analyzes your code and determines the build process 4. **Deploy** - CNAP builds and packages your application automatically 5. **Product Creation** - Deploy to your selected clusters and make it available as a product Nixpacks supports 10+ languages and frameworks out of the box, with no configuration required for most projects. ### GitHub App Integration CNAP uses a GitHub App for secure, scoped access to your repositories. This provides several advantages over personal access tokens: * **Enhanced Security** - No need to store personal access tokens * **Granular Permissions** - Control exactly which repositories are accessible * **Team Access** - All workspace members can use connected repositories * **Multiple Accounts** - Connect both personal and organization accounts * **Revocable Access** - Easily manage and revoke repository access Get started by connecting your GitHub account or organization ### Supported Languages & Frameworks * **Node.js** - Express, Next.js, SvelteKit, Remix, Nuxt * **Python** - Django, FastAPI, Flask * **Go** - Gin, Echo, Chi * **Ruby** - Rails, Sinatra * **Java** - Spring Boot, Quarkus * **Rust** - Actix, Rocket, Axum * **PHP** - Laravel, Symfony * And more! ## Docker Images Deploy pre-built container images from any public registry. ### Benefits * **Full control** - You manage the entire build process * **Any language** - Use any programming language or stack * **Existing images** - Leverage images you've already built * **Registry flexible** - Works with Docker Hub, GHCR, or any public registry ### Best For * Legacy applications with complex build requirements * Multi-stage builds with specific optimizations * Images requiring special dependencies or configurations * Teams with established Docker workflows ### How It Works 1. Provide your container image URL 2. CNAP pulls the image from the registry 3. Deploy to your selected clusters 4. Configure pricing and availability ### Image Format Specify images using standard Docker notation: ``` nginx:latest redis:7-alpine ghcr.io/owner/image:v1.2.3 docker.io/library/postgres:15 ``` Only public images are currently supported. Private registry support is coming soon. ## Choosing the Right Source Use this guide to select the best deployment method for your use case: | Use Case | Recommended Source | Why | | ---------------------------------------------- | ----------------------------- | ------------------------------------------------ | | Standard database (PostgreSQL, MySQL, MongoDB) | **Helm Charts** | Battle-tested configurations, easy clustering | | Custom web API | **GitHub Repo** | Fast iteration, automatic builds | | Existing containerized app | **Docker Image** | Full control, existing workflows | | Open source applications | **Helm Charts** | Community maintained, well documented | | Rapid prototyping | **GitHub Repo** | Quick deployments, no container knowledge needed | | Microservices | **GitHub Repo** or **Docker** | Flexible, supports both approaches | ## Security Considerations * Verify publisher badges before deployment * Review chart source code when possible * Keep charts updated for security patches * Use CNAP's built-in scanning for vulnerabilities * Ensure repository is private if it contains secrets * Use environment variables for sensitive configuration * Review Nixpacks build logs for unexpected behavior * Enable branch protection on source repositories * Only use images from trusted registries * Verify image signatures when available * Scan images for vulnerabilities before deployment * Use specific version tags instead of `latest` ## Next Steps Start deploying applications to your clusters Set up infrastructure for your applications # Clusters Source: https://docs.cnap.tech/clusters Learn how to work with clusters clusters overview A cluster is a group of one or more machines that are managed by Kubernetes to deploy your products, any dependencies, and keep them healthy. CNAP provides **Kubernetes as a Service (KaaS)** - we manage the control plane and handle all Kubernetes operations on your workers (joining, configuring, maintaining), while you stay in control of your infrastructure and billing. [Learn more about KaaS →](/clusters/kubernetes-service) ## Getting Started with Clusters Choose how you want to set up your infrastructure: Set up fully managed infrastructure in minutes Connect your existing Kubernetes infrastructure ## Managed vs. Imported Clusters ### Managed Clusters (Recommended) **Perfect for most users** - CNAP handles all the complex operations: * **Zero operational overhead** - We manage the control plane * **24/7 monitoring** - Proactive issue detection and resolution * **Security updates** - Automatic patches and Kubernetes upgrades * **Multi-cloud support** - Use any provider or mix providers [Learn how to create a managed cluster →](/clusters/create) ### Imported Clusters **For existing Kubernetes clusters** - Bring any cluster from any provider: * **Any Kubernetes cluster** - EKS, GKE, AKS, self-managed, or others * **You manage the cluster** - Control plane and worker operations remain your responsibility * **Limited CNAP management** - We handle product deployments, you handle cluster operations * **Existing investment** - Leverage current Kubernetes infrastructure * **Flexibility** - Keep your current cluster management approach{' '} [Learn how to import a cluster →](/clusters/import) ## Behind the Scenes CNAP automatically handles product deployments when customers complete purchases. The platform synchronizes your product's Helm chart resources with the destination cluster based on the customer's selected region. Each product deployment gets its own dedicated namespace for security and isolation between different customer deployments. When deployments fail or customers cancel, CNAP automatically cleans up all associated resources to keep your infrastructure tidy. **Resource strategy:** Shared clusters work well when you control the software, but consider dedicated machines or clusters for each customer if they can run custom code like container images or game server plugins. # Create a Cluster Source: https://docs.cnap.tech/clusters/create Set up managed infrastructure in minutes create cluster Setting up infrastructure to run your products is the foundation of your CNAP experience. Our managed clusters handle all the complex Kubernetes operations so you can focus on building and selling your software. ## Why Choose Managed Clusters? CNAP's **Kubernetes as a Service (KaaS)** provides fully managed infrastructure where we handle the control plane and all worker operations while you maintain control over your infrastructure choices and billing. **Perfect for most users** - CNAP handles all the complex operations: * **Zero operational overhead** - We manage the control plane * **24/7 monitoring** - Proactive issue detection and resolution * **Security updates** - Automatic patches and Kubernetes upgrades * **Multi-cloud support** - Use any provider or mix providers ## How to Create Your Cluster Navigate to the [clusters section](https://dash.cnap.tech/clusters) in your CNAP dashboard and click **"Create Cluster"**. Create or select a region name for organizing your clusters. Regions are custom labels you define to help organize your infrastructure and will be shown to customers when they purchase your products. Region names are flexible and can be changed anytime. Use descriptive names that make sense for your business, such as "Production", "US-East", "Europe", or "Development". **Examples:** * **Production** - Your main customer-facing infrastructure * **Staging** - Testing and development environment * **US-East** - Geographic indicator for customer selection * **Europe** - Regional deployment for EU customers Choose your cluster configuration: * **Cluster name** - A descriptive name for your infrastructure * **Kubernetes version** - Latest stable version (recommended) * **High availability** - Multi-zone control plane for production workloads Click **"Create"** to provision your cluster. The control plane will be ready in 2-3 minutes. You'll see the status change to "Active" when your cluster is ready for worker nodes. ## Adding Worker Capacity Once your cluster is created, you need to add compute capacity where your products will run. You have two options: **Testing locally?** Use [Multipass](/clusters/multipass) for free local testing of worker configurations before buying production servers. Multipass is built specifically for testing scenarios and works perfectly with CNAP's architecture. ### Option 1: Self-Onboarded Workers **Bring your own machines** - Maximum flexibility * Use any cloud provider or bare metal * Connect via SSH - we handle the Kubernetes setup * Mix different providers as needed * Full control over your infrastructure choices ### Option 2: Cloud API Integration (Coming Soon) **Planned automated provisioning** - Industry-leading cloud providers * We'll create and manage machines automatically * You'll pay providers directly (no markup) * Easy scaling and management * Perfect for getting started quickly ## Getting the Worker Setup Command After your cluster is active: 1. **Click on your cluster** in the dashboard 2. **Find the "Quick Actions" section** 3. **Copy the worker setup command** The command looks like: ```bash theme={null} curl -sSL https://workers.cnap.tech/join | sudo bash -s -- --token=your-cluster-token ``` **Join Token Details:** * **Expiration**: 30 minutes from generation * **Usage**: Can be used multiple times to join multiple machines Keep this command secure - it provides access to join your cluster. Regenerate the token if it's ever compromised. ## Connecting Your First Worker Create or access an Ubuntu/Debian server: * **Minimum specs**: 2 CPU, 4GB RAM * **Recommended**: 4 CPU, 8GB RAM for production * **Operating system**: Ubuntu 22.04 LTS (recommended) ```bash theme={null} ssh root@your-server-ip ``` Execute the command you copied from the dashboard: ```bash theme={null} curl -sSL https://workers.cnap.tech/join | sudo bash -s -- --token=your-cluster-token ``` The script will automatically: * Install Kubernetes components * Join the worker to your cluster Your worker will appear in the dashboard within 1-2 minutes as "Active". You can now start deploying products! ## What's Next? With your cluster ready and workers connected, you can: Turn your applications into sellable products Create a storefront where customers can buy your products Scale your infrastructure as demand grows Discover how to build profitable cloud products ## Troubleshooting * Verify the server has internet connectivity - Check that the setup command was copied correctly - Ensure you're running as root (with `sudo`) - Wait 2-3 minutes for the registration process {' '} * Check server meets minimum requirements (2 CPU, 4GB RAM) - Ensure Ubuntu/Debian operating system - Verify no conflicting Docker/Kubernetes installations - Check firewall allows outbound HTTPS connections Cloud API integration for automatic worker provisioning is coming soon. See our [roadmap →](/roadmap) for timeline and [KaaS docs →](/clusters/kaas) for details. **No problem!** CNAP's managed KaaS architecture is designed so workers don't need public IP addresses. Workers automatically create outbound connectivity tunnels to the control plane, allowing the control plane to reach the kubelet securely. This works behind firewalls, NAT, and restrictive networks. **Pro tip**: Start with one worker and add more as your customer base grows. CNAP makes it easy to scale your infrastructure without any downtime. {' '} # Import a Cluster Source: https://docs.cnap.tech/clusters/import Connect your existing Kubernetes infrastructure If you already have a Kubernetes cluster from any source, you can import it into CNAP. This works with any existing cluster - whether it's self-managed, from cloud providers (EKS, GKE, AKS), or other managed Kubernetes services. This allows you to leverage your existing investment while gaining access to CNAP's product deployment and marketplace features. ## When to Import vs. Create ### Import Your Cluster If You: * **Have existing Kubernetes clusters** - From EKS, GKE, AKS, or any other provider * **Already invested in cluster setup** - Self-managed or managed Kubernetes infrastructure * **Need specific configurations** - Custom networking, security policies, or compliance requirements * **Want to keep existing cluster management** - Maintain your current operational setup ### Consider Creating a New Cluster If You: * **Want CNAP-managed control plane** - Zero operational overhead for Kubernetes management * **Are new to Kubernetes** - Avoid the complexity of cluster operations * **Prefer simplicity** - Focus on products, not infrastructure management * **Need quick setup** - Get running in minutes with minimal configuration **New to Kubernetes?** Consider using [CNAP's managed clusters](/clusters/create) instead. We handle all the complex control plane management, so you can focus on your product rather than infrastructure operations. ## Prerequisites Before importing your cluster, ensure it meets these requirements: * **Kubernetes Version**: 1.33+ (check with `kubectl version`) * **Cluster Access**: Admin permissions, network connectivity, valid kubeconfig * **Required Permissions**: Namespace management, workload deployment, RBAC operations If you're not using admin kubeconfig, create a service account with these permissions and bind it to a ClusterRole: ```yaml theme={null} apiVersion: v1 kind: ServiceAccount metadata: name: cnap-sa --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: cnap-role rules: - apiGroups: [''] resources: ['pods', 'pods/log', 'pods/exec', 'secrets'] verbs: ['get', 'list', 'watch', 'create', 'update', 'delete'] - apiGroups: ['apps'] resources: ['statefulsets', 'statefulsets/status'] verbs: ['get', 'list', 'watch', 'create', 'update', 'delete'] - apiGroups: [''] resources: ['namespaces', 'namespaces/finalize'] verbs: ['get', 'list', 'watch', 'create', 'update', 'delete'] --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: cnap-role-binding subjects: - kind: ServiceAccount name: cnap-sa roleRef: kind: ClusterRole name: cnap-role apiGroup: rbac.authorization.k8s.io ``` ## How to Import Your Cluster Ensure you have a valid kubeconfig file with admin access to your cluster. **Test your connection:** ```bash theme={null} kubectl cluster-info kubectl get nodes ``` **Export your kubeconfig:** ```bash theme={null} # If using default location cat ~/.kube/config # Or specify custom path cat /path/to/your/kubeconfig ``` 1. Navigate to the [clusters section](https://dash.cnap.tech/clusters) in your CNAP dashboard 2. Click **"Import Cluster"** 3. Choose **"Import Existing Cluster"** **Option A: File Upload** * Click "Upload kubeconfig file" * Select your kubeconfig file * CNAP will validate the configuration **Option B: Paste Content** * Copy your kubeconfig content * Paste into the text area * Click "Validate Configuration" CNAP will test the connection and verify: * Cluster accessibility * Required permissions * Kubernetes version compatibility * Network connectivity If validation fails, check your kubeconfig and cluster permissions before retrying. Set up how CNAP will interact with your cluster: * **Cluster name** - Descriptive name for your cluster * **Default namespace** - Where new products will deploy * **Resource limits** - Optional CPU/memory constraints * **Monitoring** - Enable CNAP observability (recommended) Click **"Import Cluster"** to finalize the process. Your cluster will appear in the dashboard as "Active" and ready for product deployments. ## Best Practices for Imported Clusters ### Security Considerations * **Use dedicated service accounts** - Don't use your personal admin credentials * **Limit CNAP permissions** - Create role-based access for CNAP operations * **Network policies** - Configure appropriate network segmentation * **Regular updates** - Keep your cluster and nodes updated ### Resource Management * **Reserve capacity** - Ensure adequate resources for CNAP deployments * **Monitor usage** - Track resource consumption and scaling needs * **Backup strategy** - Maintain regular cluster and data backups * **Disaster recovery** - Have a plan for cluster failures ### Maintenance and Updates * **Coordinate updates** - Plan Kubernetes version upgrades carefully * **Test deployments** - Validate CNAP functionality after changes * **Monitor logs** - Watch for issues with imported cluster operations * **Communication** - Notify CNAP support of major infrastructure changes ## What Happens After Import? Once your cluster is imported, you can: Turn your applications into sellable products Track resource usage and performance Create a storefront for your products Discover how to build profitable cloud products ## Limitations of Imported Clusters Be aware of these limitations compared to managed clusters: | Feature | Managed Clusters | Imported Clusters | | ---------------------------- | ------------------------- | ----------------------------- | | **Control plane management** | **✓** Fully managed | **✗** Your responsibility | | **Worker node provisioning** | **✓** Automated options | **✗** Manual management | | **Automatic updates** | **✓** Handled by CNAP | **✗** You must update | | **24/7 monitoring** | **✓** Included | **\~** Limited | | **Auto-scaling** | **✓** Available | **✗** Not supported | | **Support level** | **✓** Full infrastructure | **\~** Application layer only | ## Troubleshooting * Verify cluster is accessible from the internet - Check that kubeconfig has admin permissions - Ensure Kubernetes version is 1.25 or newer - Test connection locally: `kubectl cluster-info` {' '} * Verify cluster API server is publicly accessible - Check firewall rules allow CNAP IP ranges - Ensure DNS resolution works for your cluster - Test from external network: `curl -k https://your-cluster-api:6443` {' '} * Confirm kubeconfig has cluster-admin role - Check RBAC is properly configured - Verify service account has necessary permissions - Test with: `kubectl auth can-i "*" "*" --all-namespaces` * Check cluster has adequate resources - Verify default namespace exists and is accessible - Review cluster events: `kubectl get events --sort-by=.metadata.creationTimestamp` - Contact support with deployment logs **Considering a switch?** If managing your own cluster becomes complex, you can always [create a managed cluster](/clusters/create) and migrate your workloads. CNAP makes it easy to switch between infrastructure models. {' '} # Kubernetes as a Service Source: https://docs.cnap.tech/clusters/kubernetes-service Fully managed Kubernetes clusters that scale with your business ## Overview CNAP's **Kubernetes as a Service (KaaS)** is a lightweight, open alternative to managed Kubernetes services like EKS, GKE, or AKS. We manage the control plane and handle all **Kubernetes operations** on your workers (joining, configuring, maintaining), while you maintain control over your infrastructure choices and billing relationships. ## Why KaaS Matters Managing Kubernetes control planes is notoriously complex. It requires expertise in: * Certificate management and rotation * etcd cluster operations and backup/recovery * API server configuration and security * Controller manager and scheduler tuning * Network policy and CNI configuration * Monitoring, logging, and observability setup **CNAP handles all of this for you.** Our KaaS offering provides enterprise-grade control plane management without the operational overhead. ## Core Features ### **Fully Managed Control Plane** * **Automated provisioning** - Get from zero to production-ready cluster in minutes * **Self-healing infrastructure** - Automatic recovery from component failures * **Security hardening** - Built-in security best practices and regular updates * **High availability** - Multi-zone control plane for maximum uptime ### **Kubernetes Worker Management** We handle all the complex Kubernetes operations while you stay in control of infrastructure and billing: #### Planned Cloud Integration * **Cloud provider integration** - Planned automatic machine provisioning and management * **Direct billing** - You'll pay providers directly with no markup for transparent costs * **Full lifecycle management** - We'll handle provisioning, configuration, and maintenance * **Multi-provider support** - Multiple cloud providers planned for integration #### Flexible Infrastructure * **Bring any machine** - Bare metal, VPS, cloud instances from any provider * **You control the infrastructure** - Choose hardware, provider, and manage billing directly * **We handle complexity** - Automatic joining, configuration, monitoring, and updates * **Complete flexibility** - Mix different providers or move workloads anytime **Bottom line:** You get enterprise Kubernetes operations without the operational headaches, while keeping full control over your infrastructure strategy and costs. ### **Built for Growth** * **Streamlined onboarding** - Developer-friendly experience reduces time-to-market * **Cost optimization** - Pay only for compute resources you actually use * **Seamless scaling** - Add or remove workers as your needs change * **Enterprise reliability** - Production-grade infrastructure from day one ### **Managed vs. Self-Hosted** While you can import existing Kubernetes clusters into CNAP, our managed clusters offer significant advantages: * **No operational overhead** - We handle all control plane management * **Automatic updates** - Security patches and Kubernetes version upgrades * **24/7 monitoring** - Proactive issue detection and resolution * **Built-in best practices** - Security, networking, and performance optimizations ## Getting Started Navigate to the [clusters section](https://dash.cnap.tech/clusters) and create your managed cluster. [Detailed guide →](/clusters/create) Use the bootstrap command to connect your server. Your cluster is ready! Start deploying products and serving customers immediately **New to Kubernetes?** CNAP's KaaS is designed to be beginner-friendly while remaining powerful enough for enterprise workloads. Our managed approach removes the learning curve typically associated with Kubernetes operations. KaaS seamlessly integrates with all other CNAP features including marketplace deployment, user management, billing, and monitoring. It's designed to provide a complete platform experience rather than just infrastructure. **Current vs Planned Support**: CNAP currently supports direct connection methods (including SSH) for connecting any existing infrastructure from any provider. Cloud API integrations including Hetzner Cloud, AWS, GCP, Azure, and DigitalOcean are planned features. See our [roadmap](/roadmap) for implementation timeline. # Local Testing Source: https://docs.cnap.tech/clusters/local-testing Test your applications locally with Multipass before deploying to production Multipass logo. **Multipass** is the perfect tool for testing CNAP worker configurations locally without any cloud costs. Built by Canonical specifically for testing scenarios, Multipass lets you quickly spin up Ubuntu VMs on your local machine to test worker setups before buying production machines. ## Why Multipass for CNAP Testing? Multipass is purpose-built for development and testing scenarios, making it ideal for: * **Free local testing** - No cloud costs while developing and testing products * **Rapid iteration** - Quickly create, destroy, and recreate test workers * **Production simulation** - Test exact worker setup procedures in a local environment **Performance considerations**: Local testing with Multipass will be slower than production servers due to your home internet connection (typically much slower than datacenter 1-10+ Gbps links) and limited local resources. Ensure your VM has at least 1 CPU and 3GB RAM for reliable testing. CNAP's managed KaaS architecture is designed so your workers don't need a public IP address. When a worker starts, it automatically creates an outbound konnectivity tunnel to the control plane, allowing the control plane to reach the kubelet securely. ## Prerequisites Install Multipass on your development machine: **Using Homebrew (Recommended)** ```bash theme={null} brew install multipass ``` **Manual Download** Download from [https://multipass.run](https://multipass.run) Install the .pkg file **Verify installation** ```bash theme={null} multipass version ``` **Using Snap (Recommended)** ```bash theme={null} # Ubuntu/Debian and most Linux distributions sudo snap install multipass ``` **Manual Download** Download from [https://multipass.run](https://multipass.run) Follow distribution-specific installation instructions **Verify installation** ```bash theme={null} multipass version ``` **Using Chocolatey (Recommended)** ```powershell theme={null} choco install multipass ``` **Manual Download** Download installer from [https://multipass.run](https://multipass.run) Run the .exe installer **Verify installation** ```powershell theme={null} multipass version ``` ## Setting Up a Test Worker First, ensure you have an active cluster in your [CNAP dashboard](https://dash.cnap.tech/clusters). You'll need the worker setup command from this cluster. Create a new Ubuntu VM with adequate resources for testing: ```bash theme={null} # Create VM with recommended specs for testing multipass launch --name cnap-worker --cpus 2 --memory 4G --disk 20G # Verify VM is running multipass list ``` Use `--cpus 4 --memory 8G` for more realistic production testing scenarios. ```bash theme={null} # SSH into the Multipass VM multipass shell cnap-worker ``` You're now inside the Ubuntu VM, ready to test the worker setup. In your CNAP dashboard: 1. Navigate to your [active cluster](https://dash.cnap.tech/clusters) 2. Click the **"Quick Actions"** menu 3. Select **"Add a worker"** 4. Copy the bootstrap command Inside the Multipass VM, run the worker setup command: Infrastructure setup command in the CNAP dashboard. The setup will automatically: * Install Kubernetes components * Configure networking * Join the worker to your cluster * Establish outbound tunnel to control plane Check your CNAP dashboard - the worker should appear as "Active" within 1-2 minutes. Your test worker is now connected and ready for testing product deployments! ## Testing Product Deployments With your Multipass worker connected, you can test complete product deployment workflows: 1. **Create test products** in your CNAP dashboard 2. **Deploy to test cluster** using your Multipass worker 3. **Verify deployments** work correctly 4. **Iterate configurations** without cloud costs ## Network Architecture Benefits CNAP's managed KaaS architecture provides several advantages for testing: * **No public IP required** - Your Multipass VM doesn't need external connectivity * **Outbound tunnels** - Workers create secure connections to the control plane * **Firewall friendly** - Works behind NAT, firewalls, and restrictive networks * **Secure by default** - Control plane reaches kubelet through encrypted tunnels **Important distinction**: The cluster control plane ↔ worker communication works exactly like production servers, regardless of your local network configuration. **Product ingress considerations**: If your product exposes services and expects a public IP, you'll need to use your local VM's IP address instead. Get it with `multipass info cnap-worker`. This depends on each product's deployment - some products use cloudflared tunnels which work seamlessly, while others may require manual IP configuration for local testing. ## Cleanup and Management ### VM Management ```bash theme={null} # Stop the VM when not testing multipass stop cnap-worker # Start it again when needed multipass start cnap-worker # Delete when done testing multipass delete cnap-worker multipass purge ``` ### Worker Cleanup When you're done testing, remove the worker from your cluster: 1. In CNAP dashboard, go to your cluster 2. Find the Multipass worker in the worker list 3. Remove it to keep your cluster clean ## Advanced Testing Scenarios ### Multiple Test Workers Test multi-worker scenarios by creating multiple VMs: ```bash theme={null} # Create additional test workers multipass launch --name cnap-worker-2 --cpus 2 --memory 4G --disk 20G multipass launch --name cnap-worker-3 --cpus 2 --memory 4G --disk 20G # Connect each one using the same worker setup command ``` ### Resource Constraints Testing Test with minimal resources to simulate constrained environments: ```bash theme={null} # Minimal test worker multipass launch --name cnap-minimal --cpus 1 --memory 2G --disk 10G ``` ### Network Simulation Test network scenarios by configuring Multipass networking: ```bash theme={null} # Custom network configuration multipass launch --name cnap-network-test --network name=bridge ``` ## Troubleshooting * Check available system resources (CPU, RAM, disk) * Verify Multipass service is running: `multipass version` * Try with lower resource requirements: `--cpus 1 --memory 2G` * Ensure VM has internet connectivity: `curl -I https://dash.cnap.tech/worker.sh` * Verify the worker token hasn't expired (6 hours) * Try the setup command with `sudo` explicitly * Wait 2-3 minutes for registration to complete * Check VM system time is synchronized * Verify outbound HTTPS connections work * Check CNAP dashboard shows cluster as "Active" ## Next Steps Once you've validated your worker configuration with Multipass: Use the same commands on production servers Add more workers as your customer base grows Create products to deploy on your tested infrastructure Start selling your products to customers # Regions Source: https://docs.cnap.tech/clusters/regions Learn how to group clusters regions Regions serve as organizational units for displaying regions to users instead of clusters directly. They are not tied to specific geographical locations but help users select the right group of clusters. You can edit the region of a cluster at any time, although this is often done only once during initial setup. ### Creating a Region To create a new region, use the quick create icon when adding a cluster in the dashboard. Choose a descriptive name for the region, such as "Frankfurt, Germany" or "us-east-1". create region Once a region is created, it can be associated with one or more clusters. This association allows you to group clusters geographically. # Culture & Values: Building for Builders Source: https://docs.cnap.tech/handbook/culture-and-values The principles that guide how we work and the company we aspire to be ## Our Philosophy We believe the future belongs to builders—the developers, creators, and innovators who turn ideas into reality. Everything we do serves this community, because **when builders succeed, the world advances**. Culture and values ## Core Values ### ** Bias to Action** *Ship fast, learn faster* **What this means:** * Perfect is the enemy of good—we prioritize progress over perfection * We make decisions quickly and iterate based on feedback * When in doubt, we build and test rather than debate endlessly * Every Friday is "Ship Friday"—everyone ships something, no matter how small **How we live this:** * 2-week sprint cycles with continuous deployment * "Try it Tuesday" experiments with new features * Open source contributions to the community * Rapid prototyping over lengthy planning ### ** Build for Builders** *Developers are our heroes* **What this means:** * Developer experience (DX) drives every product decision * We eat our own dog food—CNAP builds on CNAP * Documentation is as important as code * Simplicity is sophisticated—complex problems deserve elegant solutions **How we live this:** * Regular "Developer Days" where we use our own platform * All features start with developer stories, not business requirements * Open source first—proprietary only when absolutely necessary * Community feedback shapes our roadmap ### ** Open by Default** *Transparency builds trust* **What this means:** * Open standards, open ecosystem, open communication * Public roadmap, public metrics, public learnings * Default to transparency unless privacy/security requires otherwise * Share knowledge freely—rising tides lift all boats **How we live this:** * Build on open standards like Kubernetes and Helm * Public changelog and roadmap updates * Regular community calls and feedback sessions * Blog about failures and learnings, not just successes ### ** Customer Obsession** *Success is measured by customer success* **What this means:** * Customer problems are our problems * Revenue follows customer value, not the reverse * We optimize for customer lifetime happiness, not quarterly metrics * Support is everyone's job, not just support's job **How we live this:** * Everyone does customer support rotation * Customer success metrics on every dashboard * Regular customer interviews and feedback loops * Feature decisions backed by customer data ### ** Data-Driven** *Opinions are good, data is better* **What this means:** * Every decision should be measurable * We A/B test features, not just markets * Intuition guides, data decides * Failure is learning if you measure it **How we live this:** * All features ship with metrics and success criteria * Weekly data reviews across all teams * Experimentation framework for major decisions * Public metrics dashboard for transparency ## How We Work ### **Remote-First, Community-Centered** We're distributed by design, but connected by purpose: * **Async by default** - Documentation over meetings * **Global perspective** - Team spans timezones and cultures * **Flexible schedules** - Results matter, not hours * **Regular gatherings** - Quarterly in-person team events ### **Continuous Learning** Technology changes fast—we change faster: * **Experiment time** - Dedicated time for exploring new technologies * **Internal talks** - Weekly tech talks and knowledge sharing * **Conference speaking** - Company supports and encourages speaking ### **Sustainable Pace** We're building for the long term: * **Work-life integration** - Sustainable pace, not unsustainable sprints * **Mental health support** - Therapy and wellness benefits * **Time off encouraged** - Regular breaks and vacation time * **Long-term thinking** - Career development and growth opportunities ## Decision-Making Framework ### **The Developer Lens** *Would this make developers' lives better?* Every decision gets filtered through the developer experience: * Does this reduce cognitive load? * Does this save time? * Does this increase confidence? * Does this enable creativity? ### **The Community Test** *Would we be proud to open source this?* We build like the world is watching: * Code quality that we'd want others to learn from * Documentation that actually helps * APIs that we'd want to use ourselves * Practices that we'd recommend to friends ### **The Long-Term View** *How does this position us for 2030?* Short-term pressures, long-term thinking: * Does this build competitive moats? * Does this expand our ecosystem? * Does this create network effects? * Does this advance our mission? ## What We Don't Do ### **❌ Move Fast and Break Things** We move fast and **build** things. Breaking things breaks trust. ### **❌ Growth at All Costs** Sustainable growth beats unsustainable sprints. Always. ### **❌ Cargo Cult Best Practices** We adopt practices because they work for us, not because they're trendy. ### **❌ Feature Competition** We don't build features just because competitors have them. Customer value drives features. ## Communication Principles ### **Clarity Over Cleverness** * Simple words over complex concepts * Examples over abstract explanations * Direct feedback over diplomatic hints ### **Written Over Verbal** * Document decisions for future reference * Async communication respects global timezones * Public channels over private DMs when possible ### **Constructive Over Critical** * Solutions-oriented feedback * "Yes, and..." instead of "No, but..." * Assume positive intent in all interactions ## Hiring Philosophy ### **We Look For:** * **Technical competence** - Can you build great software? * **User empathy** - Do you care about developer experience? * **Learning velocity** - How quickly do you adapt to new technologies? * **Community mindset** - Do you lift others up? * **Ownership mentality** - Do you take responsibility for outcomes? ### **We Don't Care About:** * Where you went to school * How many years of experience you have * What programming languages you've used * Whether you have a computer science degree ### **Our Interview Process:** 1. **Portfolio review** - Show us what you've built 2. **Technical pairing** - Build something together 3. **Values alignment** - Culture fit conversation 4. **Customer scenario** - How would you help a struggling developer? ## Growth and Development ### **Career Paths** We support multiple growth trajectories: * **Technical leadership** - Staff engineer, principal engineer, CTO track * **Product leadership** - Product manager, product director, CPO track * **Business leadership** - Operations, sales, CEO track * **Community leadership** - Developer relations, advocacy, evangelism ### **Promotion Philosophy** * **Impact over tenure** - Results matter more than time served * **Growth mindset** - Potential matters more than current skills * **Teaching others** - Leadership means multiplying your impact through others ### **Learning Support** * **Mentorship program** - Everyone has a mentor and mentors others * **Conference budget** - Attend and speak at industry events * **Open source time** - Contribute to the ecosystem we depend on * **Side project support** - Use company resources for learning projects ## Success Stories The culture we aspire to create should produce stories like these: ### **The Weekend Hero** *A developer discovers a critical bug in production on Saturday. Instead of waiting for Monday, they dive in, fix it, document the solution, and prevent future occurrences—because our customers depend on us.* ### **The Teaching Moment** *A senior engineer spends three hours helping a junior developer understand a complex concept, creating documentation that helps the entire team—because building others up builds everyone up.* ### **The Customer Champion** *A product manager talks a customer out of a feature request that would hurt them long-term, instead proposing a better solution—because customer success beats customer satisfaction.* ### **The Open Source Contributor** *An engineer fixes a bug in an upstream dependency and contributes the fix back to the community—because we succeed when the entire ecosystem succeeds.* ## Measuring Our Culture Culture isn't just aspirational—it's measurable: ### **Quantitative Metrics** * **Employee Net Promoter Score** - Would you recommend CNAP as a workplace? * **Internal mobility rate** - Are people growing within the company? * **Knowledge sharing frequency** - How often do we teach each other? * **Open source contributions** - How much do we give back to the community? ### **Qualitative Indicators** * **Stories we tell** - What behaviors do we celebrate? * **Decisions we make** - Do our actions match our values? * **People we hire** - Are we attracting the right people? * **Feedback we receive** - What do customers and community members say about us? ## The Future of Work at CNAP As we grow, our culture will evolve, but our core remains constant: **we exist to serve the builder community**. Whether we're 10 people or 1,000, whether we're a startup or a public company, whether we're building developer tools or consumer products—we will always be builders serving builders. **That's not just our business model. That's who we are.** *** Help us build the future of managed services Read stories of our culture in practice How we interact with our developer community See our commitment to open development # Introduction Source: https://docs.cnap.tech/handbook/introduction This handbook explains how we work, what we believe, and where we're going. It is one of the most important things we've ever made. Welcome to CNAP's company handbook. This is our guide to building the future of managed services distribution—a future where deploying data center-scale software is as easy as installing an app from the App Store. Office ## Company Vision & Strategy Our long-term vision, market positioning, and the principles that guide how we work together. How CNAP is transforming cloud software distribution and creating a new category of sovereign, automated managed services. Our unique position as the managed services enablement layer and why we avoid vendor lock-in. The principles that guide how we work and the company we aspire to be. ## Business Foundation The strategic thinking, market analysis, and business fundamentals that drive our decisions. The five critical questions that drive our business strategy and decision-making. Where CNAP succeeds in the cloud ecosystem and our competitive advantages. It takes only 10 slides to explain CNAP's entire business model and vision. *** ## Why This Handbook Matters This handbook represents our commitment to **radical transparency**. We believe that by sharing how we think, work, and make decisions, we build trust with our community and attract people who share our values. Room at the office ### **For Team Members** This handbook is your guide to understanding not just what we do, but why we do it. Every decision, principle, and strategy documented here helps you make better choices and contribute more effectively. ### **For the Community** We're building in public because the developer community deserves to understand the companies that serve them. This transparency helps you decide whether CNAP aligns with your values and goals. ### **For Partners & Investors** This handbook demonstrates our strategic thinking, market understanding, and commitment to building a sustainable business that serves all stakeholders. *** **This handbook is a living document.** As we grow and learn, we'll update these pages to reflect our evolving understanding of the market, our customers, and ourselves. Have questions about anything in this handbook? [Reach out to our founders](mailto:robin@cnap.tech) or [join our Discord community](https://discord.gg/gNh9bUWVp7). # Key Business Questions Source: https://docs.cnap.tech/handbook/key-business-questions The fundamental questions that drive our business strategy ## The Five Critical Questions ### **1. How is this business creating value?** CNAP creates value by eliminating the barriers that prevent developers from turning code projects into profitable managed services: **For Developers:** * **10x faster time-to-market** - Turn any application into a managed service in hours, not months * **Built-in monetization** - Automated billing with multiple payment providers, no custom billing systems needed * **Zero infrastructure expertise** - Focus on building features, not managing Kubernetes clusters * **Cost optimization** - Choose your own infrastructure providers, avoid vendor markup and lock-in **For Customers:** * **Dedicated deployments** - Enterprise-grade isolation and performance without shared infrastructure risks * **Cost flexibility** - Run services on their preferred infrastructure for optimal cost control * **Vendor freedom** - No lock-in, can switch providers or bring services in-house anytime **For the Ecosystem:** * **Category creation** - Democratizing managed services distribution like app stores democratized mobile apps * **Innovation acceleration** - Lowering barriers for specialized, niche services to reach market ### **2. How do you attract the attention of people who might want or need what this business provides?** We target developers with successful code projects who want to monetize without vendor lock-in: **Developer-Centric Marketing:** * **Open source contributions** - Building on CNCF ecosystem and contributing back to Kubernetes community * **Category education** - Content about "sovereign managed services" and why dedicated deployments matter * **Success stories** - Showcasing developers who've built profitable managed services on CNAP * **Community building** - Active presence in Kubernetes, CNCF, and developer communities **Enterprise Outreach:** * **Compliance-first messaging** - Targeting regulated industries needing dedicated deployments * **Cost optimization case studies** - Showing infrastructure cost savings vs vendor lock-in alternatives * **Developer advocacy** - Supporting internal developer teams who want to build vs buy ### **3. How do you convince people to pay you money?** Our value proposition removes the biggest obstacles to managed service success: **For Service Providers (Developers):** * **Revenue acceleration** - Start earning from day one with built-in billing and automation * **Risk reduction** - No upfront infrastructure investment, pay as you scale * **Competitive advantage** - Offer dedicated deployments while competitors offer shared hosting **For Service Buyers (Enterprises):** * **Better economics** - Dedicated resources without managed service premium pricing * **Strategic flexibility** - No vendor lock-in, can optimize costs or change providers * **Compliance ease** - Purpose-built for data protection and regulatory requirements **Pricing Strategy:** * **Usage-based model** - Align our success with customer success * **No vendor markup** - Customers pay infrastructure costs directly, avoiding markup * **Free trial tier** - Let developers experience the platform before committing ### **4. How does the business deliver the value that it promises to its paying customers?** CNAP delivers through automated infrastructure that eliminates operational complexity: **Technical Delivery:** * **Automated KaaS** - Managed Kubernetes clusters with zero operational overhead * **Built-in billing integration** - Multiple payment providers, usage tracking, automated invoicing * **Multi-tenant isolation** - Secure, dedicated environments for each customer * **Open standards** - Helm-native deployments on industry-standard Kubernetes **Business Model Delivery:** * **Platform as backbone** - Service providers maintain customer relationships, CNAP powers infrastructure * **No marketplace dependencies** - Avoid chicken-and-egg problems of traditional marketplaces * **Cost transparency** - Clear, predictable pricing with no hidden vendor markups ### **5. How is the business spending money and is it bringing more than it is spending?** **Investment Areas:** * **Platform engineering** - Building the automation that eliminates manual DevOps work * **Category education** - Teaching market about sovereign managed services and vendor freedom * **Developer ecosystem** - Community building and open source contributions * **Enterprise partnerships** - Relationships with infrastructure providers and system integrators **Revenue Streams:** * **Platform fees** - Subscription for CNAP platform access and automation * **Usage-based fees** - Percentage of customer billing processed through the platform * **Infrastructure partnerships** - Revenue sharing with cloud providers and bare metal hosts **Path to Profitability:** The business model scales efficiently because: * **Automated operations** - Platform serves more customers without linear cost increases * **Network effects** - More developers attract more customers, creating virtuous cycles * **Infrastructure leverage** - No need to own expensive data centers or compete on commodity infrastructure ### **6. Is it enough to put all the energy, time and effort into the business worthwhile?** **Market Opportunity:** * **\$100B+ cloud services market** transitioning from centralized to distributed * **Category creation** - We're not competing in existing markets, we're creating new ones * **Sustainable competitive advantage** - Network effects and ecosystem lock-in (the good kind) **Strategic Value:** * **Developer freedom** - Enabling thousands of developers to build sustainable businesses * **Customer choice** - Breaking vendor lock-in and promoting infrastructure competition * **Innovation acceleration** - Democratizing access to enterprise-grade managed services **Personal Fulfillment:** We're solving problems that matter: * **Economic empowerment** - Helping developers turn code into sustainable income * **Technology advancement** - Making cutting-edge infrastructure accessible to everyone * **Market evolution** - Driving the industry toward more open, competitive models **The effort is worthwhile because we're not just building a company—we're establishing a new category that will define the next decade of cloud software distribution.** # Our Market Fit Source: https://docs.cnap.tech/handbook/pmf Where CNAP succeeds in the cloud ecosystem ## The Market Reality We identified that developers who prioritize cost-efficiency often rely on simpler solutions like shared infrastructure or managed platforms like Vercel and Cloudflare Workers. However, these solutions force a choice between **simplicity** and **control**. For CNAP to succeed, we serve the niche that refuses to make this trade-off—developers and enterprises who need both. ## Our Sweet Spot CNAP delivers **data protection, performance isolation, automated operations, AND cost optimization** together. We serve developers who need enterprise-grade managed services without vendor lock-in or enterprise-grade complexity. ### **Where CNAP Excels** **1. Regulated Industries and Compliance:** * Industries like finance, healthcare, and government require **per-customer isolation** to meet compliance standards (e.g., GDPR, HIPAA, SOC 2). Shared infrastructure cannot satisfy these needs. * CNAP's architecture, which provisions isolated Kubernetes clusters for each customer, ensures compliance-ready isolation and auditability while maintaining cost efficiency through infrastructure choice. **2. High-Performance Applications:** * Shared deployments lead to noisy-neighbor issues, causing performance degradation and unpredictable costs. CNAP's per-customer clusters guarantee predictable performance without resource contention. * Target developers working on SaaS platforms where **real-time performance** is critical (e.g., analytics platforms, gaming backends, financial trading systems). **3. Enterprise SaaS Vendors:** * Mid-to-large-scale enterprises demand dedicated environments for reliability, SLAs, and security. CNAP appeals to developers targeting these enterprise customers who require white-labeled environments or bespoke setups. * Unlike traditional managed services, CNAP enables cost optimization through infrastructure provider choice while maintaining enterprise-grade isolation. **4. Developers Scaling Beyond Shared Infrastructure:** * Startups or individual developers initially running shared infrastructure might outgrow it as customer demands increase. CNAP provides a growth path, offering tools to transition to isolated infrastructure easily. * Critical advantage: **incremental adoption** without vendor lock-in, allowing developers to optimize costs as they scale. **5. Cost Predictability for Multi-Tenant Applications:** * Multi-tenancy on shared infrastructure introduces unpredictable scaling issues, as one customer's usage spike may require costly overprovisioning. Per-customer clusters eliminate this uncertainty and can reduce unexpected costs. * CNAP's model allows precise cost allocation per customer while avoiding vendor markup and lock-in penalties. **6. Developers Lacking Infrastructure Expertise:** * Developers who want a **plug-and-play solution** for creating managed services without needing to build their own billing, monitoring, or scaling systems. * Unlike cloud giants, CNAP provides this simplicity while maintaining cost control and vendor freedom. ## What Sets CNAP Apart ### **1. Developer Experience:** * CNAP provides an **opinionated framework** for managed service creation, combining automated cluster provisioning, Helm-based deployment, and integrated billing with multiple payment providers. * Unlike raw Kubernetes or DIY solutions, CNAP abstracts complexity while remaining open enough to avoid vendor lock-in. Unlike traditional PaaS, CNAP preserves cost optimization capabilities. ### **2. Ease of Transition:** * Developers can start with shared infrastructure or simpler setups, then add CNAP for specific customers requiring dedicated environments or compliance guarantees. This **incremental adoption** lowers entry barriers. * Critical differentiator: no forced migration or vendor lock-in penalties—optimize costs and infrastructure choices at your own pace. ### **3. API-first Model:** * CNAP offers APIs for seamless integration into existing CI/CD pipelines, enabling developers to onboard new customers programmatically without overhauling their workflows. * Built for the modern development ecosystem while maintaining infrastructure choice and cost control. ### **4. Value Over DIY:** * Building per-customer infrastructure (even with tools like Kubernetes) requires significant effort to set up and maintain. CNAP's focus on automation ensures developers save time while maintaining control over deployments and costs. * Unlike managed services that hide costs and create lock-in, CNAP provides transparency and choice. ## Audiences We Don't Target ### **1. Hobbyists with Simple Projects:** * Those building small-scale projects or personal apps that don't need multi-tenancy or dedicated deployments. These users are well-served by platforms like Cloudflare or Vercel. * **Note:** This isn't about cost-sensitivity—it's about use case complexity. Many hobbyists eventually need CNAP's capabilities as they scale. ### **2. Small Businesses with Minimal Compliance Needs:** * Businesses that don't require per-customer isolation or regulated environments are better served by simpler, shared multi-tenancy solutions initially. * However, these often become CNAP customers as they grow and need better cost control or compliance. ### **3. Enterprises with Large DevOps Teams:** * Companies with extensive DevOps capabilities may prefer fully custom infrastructure. They're more likely to use Kubernetes directly. * **Opportunity:** Even these enterprises often need CNAP for specific use cases requiring rapid deployment or cost optimization. ## Our Primary Target Audiences ### **1. Small-to-Medium SaaS Developers:** * Target developers who want to scale their open-source projects into managed services but lack the resources to build infrastructure from scratch. * Key value: **fast time-to-market with cost optimization** built in from day one. ### **2. Vertical SaaS Providers:** * Developers building SaaS solutions for regulated industries like healthcare, finance, or government, where compliance and customer isolation are key. * CNAP's dedicated deployment model meets compliance needs while maintaining cost efficiency through infrastructure choice. ### **3. Agencies or Service Providers:** * Agencies managing multiple clients or customer deployments benefit from CNAP's per-customer clusters and built-in management. * Critical advantage: **transparent cost allocation** and the ability to optimize infrastructure costs for each client. ### **4. Early-Stage Startups:** * Startups seeking to launch managed offerings quickly without hiring specialized DevOps talent. * CNAP enables rapid scaling while preserving the ability to optimize costs and avoid vendor lock-in as they grow. ## CNAP's Core Value Proposition CNAP's differentiation lies in **enabling developers to scale faster, meet compliance demands, and optimize costs with minimal operational overhead**: * **Reduced operational burden:** Automated cluster setup and app lifecycle management free developers from DevOps-heavy workflows * **Faster time-to-market:** Pre-built components for billing with multiple payment providers, monitoring, and scaling cut development time * **Cost optimization:** No vendor markup, infrastructure provider choice, transparent pricing * **Vendor freedom:** No lock-in penalties, ability to switch providers or bring services in-house * **Adaptability:** CNAP's modularity allows developers to start small and adopt additional features as needed * **Monetization-focused:** Built-in billing and tracking help developers monetize services with maximum profit margins ## Competitive Advantages Unlike platforms that force you to choose between **simplicity** (shared hosting with vendor lock-in) or **control** (complex raw Kubernetes), CNAP provides both: * **Simple as SaaS** - App Store-like deployment experience * **Control like self-hosted** - Your infrastructure, your data, your terms * **Cost optimized** - No vendor markup, choose your providers, optimize spending * **Freedom from lock-in** - Avoid overpaying and maintain cost flexibility * **Built for scale** - Automated operations from customer #1 to customer #1000+ ## Making Adoption Frictionless ### **1. Managed Infrastructure Offering:** Provide a hosted CNAP option where everything (from clusters to billing) is fully managed by CNAP, but with transparent cost pass-through and provider choice. ### **2. Self-Hosted Edition:** Offer a Kubernetes-native, easy-to-install version for developers who prefer self-hosting and want maximum cost control. ### **3. Developer-friendly APIs:** Enable seamless integration with existing workflows without forcing platform lock-in or hidden cost escalations. ### **4. Free Tier and Transparent Pricing:** Offer free trials with clear, predictable pricing that scales with usage but never includes vendor markup or lock-in penalties. ## Success Metrics We know we've achieved product-market fit when: * **Developers choose CNAP over building custom managed service infrastructure** due to faster time-to-market and better cost economics * **Customers prefer CNAP-powered services over traditional SaaS offerings** because of dedicated deployments and cost transparency * **Enterprise buyers value dedicated deployments with cost optimization** over shared multi-tenancy with vendor markup ## Market Positioning Summary CNAP's value lies in offering **scalable, isolated, compliance-ready infrastructure with cost optimization and vendor freedom**. By targeting developers with specific needs (compliance, performance guarantees, cost control, or multi-tenancy challenges), CNAP carves a niche distinct from simpler platforms like Vercel or complex solutions like raw Kubernetes. **The future belongs to specialized managed services with dedicated infrastructure and cost transparency.** CNAP makes that future accessible to every developer while preserving their freedom to optimize and control their economics. *** **Key insight:** We're not competing on cost alone or features alone—we're competing on **freedom**. Freedom from vendor lock-in, freedom to optimize costs, freedom to choose infrastructure, and freedom to scale without penalty. This is what differentiates us in the market. # Roadmap Source: https://docs.cnap.tech/handbook/roadmap Learn about the roadmap of CNAP ## Products * Support Helm charts from private Git/OCI repositories * Allow metered type Stripe pricings together with Prometheus metrics * Deploying one product to multiple clusters in one checkout *** ## Clusters * Create managed clusters - Automatic worker provisioning via cloud APIs * Per-customer/per-deployment dedicated clusters - Allow deploying products to a customer's cluster instead of the seller's cluster - Automatic cluster scaling based on demand *** ## Infrastructure Providers * Support for Hetzner Cloud, AWS, GCP, Azure, and DigitalOcean cloud APIs - Expand cloud API integrations beyond self-onboarded workers with cloud-init. *** ## Workspaces * Deleting empty workspaces that don't have any critical resources (Clusters, Product Deployments) - Editing workspace name and icon *** ## Regions * Allow selecting predefined icons while creating a region * Dedicated management UI for regions (listing, creating, deleting, editing) # Strategic Positioning: The Platform of Platforms Source: https://docs.cnap.tech/handbook/strategic-positioning How CNAP occupies a unique position in the cloud ecosystem ## The Platform Layer Revolution CNAP operates in a unique layer of the cloud stack that traditional providers haven't addressed: **the managed services enablement layer**. We're not competing with AWS, Azure, or GCP—we're making them more valuable by enabling anyone to build managed services on top of them. More importantly, we provide freedom from vendor lock-in by supporting any cloud provider, bare metal, or hybrid infrastructure. Layered art ## Market Positioning Matrix ### **What We're NOT** **We don't compete with AWS/Azure/GCP** * We make their infrastructure more valuable * Customers can use any cloud provider * Multi-cloud by design, vendor lock-in by choice **We don't build applications** * We enable others to monetize their applications * Platform for platforms, not end-user applications * Infrastructure for service providers **We don't own the application lifecycle** * Customers control their applications and data * No platform lock-in or proprietary APIs * Open standards and portability ### **What We ARE** **The infrastructure for SaaS-ifying code projects** * Turn any application into a managed service * Built-in multi-tenancy, payment processing, and automated operations * Enable service providers to deliver exceptional customer experiences with dedicated deployments **Making data center-scale deployment as simple as the App Store** * Backbone infrastructure enabling service providers to reach customers * One-click deployment to any infrastructure * Global distribution network built on open standards **The payment rails for cloud services** * Automated billing and usage tracking with multiple payment providers * Flexible pricing models and global payment processing * Revenue optimization for developers turning code into sustainable businesses ## The Three-Layer Strategy ### **Layer 1: Infrastructure Abstraction** *Making Kubernetes accessible to everyone* **Challenge**: Kubernetes is too complex for most developers\ **Solution**: Managed KaaS with zero operational overhead\ **Outcome**: Developers focus on applications, not infrastructure ### **Layer 2: Monetization Engine** *Turning code into cash flows* **Challenge**: Building billing and multi-tenancy is hard\ **Solution**: Built-in payment provider integrations and tenant isolation\ **Outcome**: Instant monetization for any application with dedicated deployments ### **Layer 3: Distribution Network** *Global marketplace for managed services* **Challenge**: Discovering and deploying cloud services is fragmented\ **Solution**: Unified marketplace with one-click deployment\ **Outcome**: Efficient matching of software to customers ## Competitive Moats ### ** Network Effects** The more developers build on CNAP, the more valuable it becomes: * More applications → More customer choice * More customers → More developer revenue through dedicated deployments * More success stories → Faster ecosystem adoption * More infrastructure providers → Lower costs for everyone **No marketplace chicken-and-egg problem**: Service providers maintain their own websites and customer relationships. CNAP serves as the backbone infrastructure that powers their managed services. ### **🔒 Technical Complexity** Our core capabilities are difficult to replicate: * **Multi-tenant Kubernetes architecture** - Years of R\&D investment * **Billing integration depth** - Complex metering and pricing logic * **Security isolation** - Enterprise-grade tenant separation * **Global infrastructure** - Distributed control plane management ### ** Data Advantage** We accumulate anonymized insights that improve the platform while maintaining strict data privacy: * **Deployment patterns** - Optimize infrastructure allocation while keeping customer data isolated * **Usage analytics** - Improve pricing recommendations with privacy-first design * **Performance metrics** - Enhance application optimization without accessing customer data * **Market insights** - Guide product development using aggregated, anonymized metrics **Privacy-first approach**: With dedicated deployments, customer data remains completely isolated. CNAP never accesses or stores customer application data. ### ** Value-Based Retention** Customers stay because of continuous value creation: * **Business success alignment** - CNAP becomes integral to revenue growth * **Customer experience enhancement** - Platform enables better service delivery * **Operational efficiency** - Deep integration streamlines development workflows * **Community benefits** - Network of developers, customers, and infrastructure partners ## Market Timing: The Perfect Storm ### **Technology Convergence** * **Kubernetes maturity** - Now stable and widely adopted * **Cloud commoditization** - Infrastructure is no longer differentiating * **Containerization** - Applications are finally portable * **Helm ecosystem** - Packaging standard is established ### **Economic Drivers** * **Developer productivity crisis** - Teams spending 70% of time on operations * **Cloud cost optimization** - Need for more efficient resource utilization * **Software monetization gap** - Great OSS projects struggling to generate revenue * **Service specialization trend** - Customers want best-of-breed solutions ### **Cultural Shifts** * **Remote-first development** - Need for better collaboration tools * **Open source business models** - Growing acceptance of commercial OSS * **API-first architecture** - Everything is becoming a service * **Developer experience focus** - DX is the new competitive advantage ## Strategic Partnerships We create win-win relationships across the cloud ecosystem: ### **Infrastructure Providers** **What they get**: More valuable infrastructure utilization, stickier customers **What we get**: Diverse deployment options, global reach * **Major clouds** (AWS, Azure, GCP): Enable managed services on their platforms * **Regional providers**: Extend reach globally * **Bare metal providers**: Support high-performance, dedicated deployments ### **Developer Ecosystem** **What they get**: Enhanced workflows, integrated experiences **What we get**: Seamless developer onboarding, reduced friction * **CI/CD platforms**: Automate deployment and update workflows * **Monitoring tools**: Integrate observability and performance insights * **Package managers**: Streamline application discovery and installation ### **System Integrators** **What they get**: New revenue streams, differentiated service offerings **What we get**: Enterprise reach, implementation expertise, market validation * **Cloud consultants**: Help enterprises adopt managed service models * **DevOps specialists**: Provide implementation and migration services * **Compliance experts**: Enable regulated industry deployments ### **Open Source Projects** **What they get**: Sustainable monetization, wider adoption **What we get**: Rich application ecosystem, community-driven growth * **Popular OSS maintainers**: Turn projects into sustainable businesses * **CNCF ecosystem**: Leverage and contribute to cloud-native standards * **Emerging projects**: Early partnership for mutual growth ## Go-to-Market Evolution ### **Phase 1: Developer Adoption (Current)** **Target**: Individual developers and small teams * **Strategy**: Freemium model, self-service onboarding * **Channels**: Developer communities, content marketing * **Metrics**: Developer sign-ups, first deployments ### **Phase 2: Team Expansion (2025)** **Target**: Development teams and startups * **Strategy**: Team plans, collaborative features * **Channels**: Referrals, partner integrations * **Metrics**: Team adoption, revenue per customer ### **Phase 3: Enterprise Adoption (2026+)** **Target**: Large organizations and service providers * **Strategy**: Enterprise features, dedicated support * **Channels**: Direct sales, system integrator partners * **Metrics**: Enterprise deals, platform GMV ## Defensive Strategies ### **Against Big Tech** * **Speed advantage** - Move faster than large organizations * **Focus advantage** - Specialized solution vs. general platform * **Ecosystem advantage** - Open standards vs. proprietary lock-in ### **Against Incumbents** * **Technology advantage** - Modern architecture vs. legacy systems * **User experience advantage** - Developer-first vs. enterprise-first design * **Business model advantage** - Aligned incentives vs. extractive pricing ### **Against New Entrants** * **Network effects** - First-mover advantage creates switching costs * **Data moats** - Accumulated insights improve product over time * **Ecosystem barriers** - Established developer and partner relationships ## Success Metrics by Layer ### **Infrastructure Layer** * Cluster uptime and performance * Worker node efficiency * Cost optimization achieved ### **Monetization Layer** * Revenue processed through platform * Customer lifetime value * Developer revenue growth ### **Distribution Layer** * Applications in marketplace * Deployment velocity * Customer acquisition cost ## The Compounding Effect Each strategic layer reinforces the others: **Better Infrastructure** → **More Developers** → **More Applications** → **More Customers** → **More Revenue** → **Better Infrastructure** This creates a **virtuous cycle** that becomes increasingly difficult for competitors to break as the platform scales. *** **Category Creation**: CNAP isn't just building a product—we're establishing a new category and becoming the standard for sovereign, automated managed services distribution. The market for "Infrastructure Automation meets App Store simplicity" is ours to define and lead. # Team Source: https://docs.cnap.tech/handbook/team The people behind CNAP At CNAP, our team is a blend of builders, operators, and storytellers. We bring together deep technical know-how, sharp business and financial acumen, and creative marketing energy. Each person brings something unique, and together we push each other—and the company—forward. Team # Vision 2030: The Managed Services Revolution Source: https://docs.cnap.tech/handbook/vision-2030 How CNAP is transforming the future of cloud software distribution ## The Future We're Building By 2030, every valuable piece of software will be available as a managed service. Deploying data center-scale software will be as easy as installing an app from the App Store. Today, brilliant developers create amazing code projects, but most never become sustainable businesses. We're changing that. **CNAP isn't just building a product—we're establishing a new category and becoming the standard for managed services distribution.** Vision art ## The Managed Services Economy We envision a world where: ### **For Developers** * **10x faster time-to-market** - From code to customer in hours, not months * **Focus on innovation** - Zero time spent on infrastructure operations * **Global reach from day one** - Deploy anywhere, scale everywhere * **Sustainable revenue streams** - Turn passion projects into profitable businesses ### **For Customers** * **Infinite choice** - Access thousands of specialized managed services * **Zero vendor lock-in** - Run services on your infrastructure, your terms, your jurisdiction * **Instant deployment** - App Store-like experience for enterprise software * **Performance & isolation** - Dedicated deployments with enterprise-grade security and privacy ### **For the Industry** * **Democratized cloud services** - Small teams compete with tech giants * **Innovation acceleration** - Faster iteration cycles across all sectors * **Resource optimization** - Shared infrastructure, maximized efficiency * **Open ecosystem** - Standards-based, interoperable services ## Three Waves of Transformation ### **Wave 1: The Foundation (2024-2025)** *Building the infrastructure layer* * **Kubernetes as a Service** - Managed control planes for everyone * **Billing & Multi-tenancy** - Built-in monetization capabilities * **Developer Experience** - Helm-native packaging and deployment * **Early adopters** - Forward-thinking developers and startups **Current Phase**: Establishing the core platform and onboarding early customers ### **Wave 2: The Marketplace (2025-2027)** *Creating the managed services ecosystem* * **Application marketplace** - Thousands of ready-to-deploy services * **AI-powered recommendations** - Smart service discovery and composition * **Enterprise features** - Advanced compliance, security, and governance * **Channel partnerships** - Integration with major cloud providers ### **Wave 3: The Standard (2027-2030)** *Becoming the default way to distribute cloud software* * **Universal deployment** - Every cloud-native application available as managed service * **Global infrastructure** - Distributed edge deployment capabilities * **Autonomous operations** - AI-driven optimization and self-healing * **Industry transformation** - Managed services as the dominant distribution model ## Market Vision: The \$100B Opportunity The global cloud services market is fragmenting from a few mega-platforms to thousands of specialized services: ### **Current State: Centralized** * **5 mega-clouds** control 80% of market * **High barrier to entry** for new service providers * **Limited choice** for customers * **Innovation bottlenecks** at platform providers ### **Future State: Distributed** * **10,000+ managed services** across all industries * **Low barrier to entry** - anyone can become a service provider * **Infinite customer choice** - specialized solutions for every need * **Innovation explosion** - rapid iteration and specialization **The Parallel**: Just as mobile app stores democratized software distribution, CNAP democratizes cloud service distribution. ## Strategic Pillars ### **1. Developer-First** Every decision optimizes for developer experience and success * **Minimal learning curve** - Familiar tools and patterns * **Rapid feedback loops** - Deploy and test in minutes * **Community-driven** - Open standards and collaboration ### **2. Infrastructure Agnostic** Run anywhere, avoid vendor lock-in * **Multi-cloud by design** - AWS, GCP, Azure, bare metal, hybrid infrastructure * **Customer choice** - Your infrastructure, your terms * **Open standards** - Built on CNCF ecosystem - Kubernetes' industry-standard foundation, benefiting from ongoing ecosystem innovations including AI workload support and future capabilities ### **3. Monetization Built-In** Turn code into cash flows * **Billing automation** - Multiple payment provider integrations, usage metering * **Flexible pricing** - Subscriptions, usage-based, one-time payments * **Global payments** - Support customers worldwide with local payment methods ### **4. Operational Excellence** Enterprise-grade reliability and security * **Self-healing infrastructure** - Automated recovery and scaling * **Multi-tenant isolation** - Secure customer separation * **Compliance ready** - SOC2, GDPR, industry standards ## Competitive Advantages ### **vs. Traditional Cloud Platforms** * **Specialized over generalized** - Purpose-built for managed services * **Developer economics** - Better revenue sharing and control * **Faster innovation** - Dedicated to solving distribution problems ### **vs. PaaS Solutions** * **Infrastructure ownership** - Customers control their destiny * **Multi-tenancy native** - Built for service providers * **Billing integration** - Monetization from day one ### **vs. Self-Built Solutions** * **Time to market** - Months to minutes * **Operational burden** - Zero infrastructure management * **Best practices** - Industry-proven patterns and security ## Success Metrics: The North Star By 2030, we measure success by: * **📈 10,000+ applications** available as managed services * **🌍 100+ countries** with local CNAP infrastructure * **💰 \$10B+ in GMV** processed through the platform * **👥 1M+ developers** building on CNAP * **🏢 50%+ of B2B SaaS** deployed via managed service model ## Cultural Values ### **🚀 Bias to Action** Ship fast, learn faster. Perfect is the enemy of good. ### **🔧 Build for Builders** Developers are our heroes. Everything serves their success. ### **🌐 Open by Default** Open source, open standards, open ecosystem. ### **💡 Customer Obsession** Customer success drives product decisions. ### **📊 Data-Driven** Measure everything, optimize continuously. ## The Network Effect As more developers build on CNAP: * **More applications** → More customer choice * **More customers** → More developer opportunity * **More infrastructure** → Lower costs for everyone * **More success stories** → Faster ecosystem growth This creates a **virtuous cycle** where each participant's success amplifies the entire ecosystem. ## Join the Revolution We're not just building a platform—we're catalyzing a transformation in how software reaches users. Every line of code you write, every service you deploy, every customer you serve advances this vision. **The future of software distribution is sovereign, automated, and as simple as an app store.**\ **The time to build that future is now.** Turn your code into a managed service today Connect with fellow builders and innovators Help shape the future of cloud services Be part of the managed services revolution *** *"The best way to predict the future is to build it."* — **CNAP Team** # Manual Quickstart Steps Source: https://docs.cnap.tech/manual The following guide helps you navigate to get your product live with the CNAP dashboard, instead of using the [interactive quickstart](/quickstart). ## Getting Started **Prerequisites:** You'll need a CNAP account and access to a machine (VPS, cloud instance, or local server) where you can run a simple command. First, we need to prepare the infrastructure where your products will run. Don't worry - this is a one-time setup that takes just a few clicks. 1. **[Navigate to Clusters](https://dash.cnap.tech/clusters)** in your CNAP dashboard 2. **Click "Add a cluster"** 3. **Choose your region** (create a custom name for organizing your infrastructure) 4. **Click "Add cluster"** to create the cluster Creating infrastructure in CNAP dashboard Your Kubernetes API will be ready in 2-3 minutes. You'll see the status change to "Active" when it's available. CNAP manages all the complex Kubernetes operations behind the scenes - certificates, networking, scaling, and monitoring are all handled for you. Now you need to add compute capacity where your products will actually run. This is where your customers' applications will live. 1. **Click the "Quick Actions" of your [active cluster](https://dash.cnap.tech/clusters)** 2. **Click "Add a worker"** 3. **Copy the bootstrap command** Infrastructure setup command in dashboard 4. **Get a server** - Create a new cloud instance or use an existing machine (minimum: 2 CPU, 4GB RAM) 5. **Connect to your server using your preferred method** ```bash theme={null} ssh root@your-server-ip ``` 6. **Run the bootstrap command on your server copied above** Infrastructure setup command in the CNAP dashboard. **Want to test locally first?** Use [local testing](/clusters/local-testing) to test worker setups on your local machine for free before buying production servers. Perfect for development and testing scenarios. Now it's time to package your software into a sellable product. This is where you define what customers will buy and deploy. 1. **Navigate to [Products](https://dash.cnap.tech/products)** in your CNAP dashboard 2. **Click "Add Product"** 3. **Choose your software** - Select a Helm chart from Artifact Hub or use your own 4. **Select regions** - Choose which clusters customers can deploy to (displayed as regions) 5. **Set up pricing** (optional) - Connect with Stripe to charge customers adding a product **Coming soon:** Support for Helm charts from private Git repositories and OCI registries. Want to charge customers for your software? Connect with Stripe to enable paid deployments: Go to [Settings → Stripe](https://dash.cnap.tech/settings/stripe) and connect your Stripe account to enable payments. connect stripe In your Stripe dashboard, create products with prices. Examples: * **\$10/month** - Monthly subscription * **\$50** - One-time setup fee * **\$5/user/month** - Per-seat pricing stripe add product Back in CNAP, your Stripe prices will automatically appear. Select which ones apply to this product. price selection You can combine multiple prices - customers will pay all selected prices when they deploy your product. **Click "Add Product"** to finish creating your sellable software product. **Congratulations!** Your software is now packaged and ready for customers. You can start selling immediately through your CNAP marketplace. # Marketplace Source: https://docs.cnap.tech/marketplace Learn how to expose your product to the marketplace marketplace overview The [marketplace](https://dash.cnap.tech/marketplace) is a collection of public products created by other sellers like you. Customers can find and deploy these products via simple checkout flows. ## Adding a Product to the Marketplace Products are added to the public marketplace as soon as they reference Stripe prices. Note that you do not need to use CNAP's marketplace to sell your product. You can always sell your product directly to your customers via your own website by linking to the product's page as a final step. We plan to add APIs to integrate and embed the marketplace in your own website and apps. We plan to add a manual approval process for products in the future. # Payments & Billing Source: https://docs.cnap.tech/payments How CNAP handles payments, Stripe integration, and customer billing ## Overview CNAP uses Stripe Connect to enable marketplace payments, allowing workspace owners to monetize their applications. The payment system is designed to be secure, reliable, and transparent. ### Key Features * **Stripe Connect Integration**: Each merchant workspace has its own Stripe account * **Automated Customer Management**: Customers are automatically created and linked to workspaces * **Workspace-Based Billing**: All installs are tied to workspace ownership, not individual users ## Payment Flow Users browse the marketplace and select a product to deploy. When a user clicks "Deploy", CNAP validates: * User is authenticated * User is a member of the target workspace * Product has valid Stripe configuration * User is not deploying to their own product's workspace Any workspace member can initiate checkout, but the billing is tied to the customer's workspace owner. CNAP automatically determines the billing customer: 1. **Search for existing customer**: Check Stripe for a customer with `metadata.workspaceId` matching the buyer's workspace 2. **Lookup workspace owner**: If no customer exists, query the workspace to find the user with the `owner` role 3. **Create customer**: Create a new Stripe customer with: * `metadata.workspaceId`: The buyer's workspace ID (for lookup) * `metadata.userId`: The workspace owner's user ID (not the person creating checkout) * `email`: The owner's email address * `name`: The owner's name (or derived from the owner's email) The Stripe customer is **always** the workspace owner, not the person initiating the checkout. This ensures billing responsibility stays with the workspace owner regardless of which team member makes the purchase. A Stripe checkout session is created with: * The product's prices * Platform fee (percentage-based) * Success/cancel URLs * Customer ID * Metadata (userId, workspaceId, productId, regionId) The user is redirected to Stripe's hosted checkout page. User completes payment on Stripe's checkout page. Stripe handles: * Payment method collection * 3D Secure authentication * Payment processing * Receipt generation Stripe sends a `checkout.session.completed` webhook to CNAP, which triggers: 1. Install creation in the database 2. Product deployment to the cluster 3. Email notification to the customer and merchant The deployment workflow includes compensation logic to rollback changes if any step fails. ## Stripe Customer Management ### Why Workspace Owners? CNAP associates Stripe customers with workspace owners rather than individual users for several important reasons: Workspace owners have administrative and financial responsibility for their workspace. All purchases made by any workspace member should be billed to the workspace owner's account. If customer records were tied to individual users, different team members making purchases would create multiple customer records for the same workspace, fragmenting billing history and complicating accounting for the merchant. Team members can come and go, but the workspace owner remains responsible. This prevents billing issues when employees leave or team structure changes. By storing `workspaceId` in Stripe customer metadata, CNAP can quickly find the customer record using Stripe's search API without maintaining a separate database table. ### Customer Metadata Schema Stripe customers created by CNAP include the following metadata: The customer's workspace ID. This is the **primary lookup key** used to find existing customers when creating checkout sessions. The workspace owner's user ID at the time of customer creation. This is used for reference but may become stale if workspace ownership changes. Future implementations may update this field when workspace ownership changes. ### Customer Lifecycle * **Creation**: Customers are created automatically during the first checkout from a workspace. The workspace owner's details are looked up and stored in the Stripe customer record. * **Reuse**: Subsequent checkouts from the same workspace reuse the existing customer record. This is achieved by searching Stripe for `metadata.workspaceId`. * **Persistence**: Customer records are **never deleted**, even if an install fails. This allows safe reuse across multiple purchases and prevents unnecessary recreation. * **Updates**: Customer details (email, name) are not automatically updated if the workspace owner changes. This is a known limitation for future improvement. ## Platform Fees CNAP collects a platform fee on all transactions: * **Payment Mode**: Fixed percentage calculated on total transaction amount * **Subscription Mode**: Percentage of subscription amount collected on each billing cycle * **Implementation**: Stripe Connect's `application_fee` handles collection automatically ## Error Handling & Reliability If payment fails at Stripe's checkout, no deployment is initiated. Users can retry by creating a new checkout session. If deployment fails after payment succeeds: This scenario requires **manual intervention** currently. The system uses workflows with infinite retries for transient failures, but non-retryable errors may result in a customer paying without receiving their deployment. **Current Behavior**: * Retryable failures (network issues, temporary cluster unavailability): Infinite retry for up to 10 years * Non-retryable failures (invalid configuration): Workflow fails and compensation rolls back database changes **Planned Improvements**: 1. Implement payment hold → deploy → capture flow 2. Automated refunds for deployment failures 3. Parent workflow for orchestration and monitoring 4. Customer notifications for stuck deployments The system ensures idempotent operations: * **Install Creation**: Stripe event ID used as idempotency key (`idk_{event_id}`) * **Customer Creation**: Search by `workspaceId` before creating * **Workflow Execution**: Workflow IDs prevent duplicate executions ## Best Practices Merchant workspaces must complete Stripe onboarding with `charges_enabled: true` before products can be sold. Ensure products have at least one Stripe price configured. CNAP validates this before allowing checkout. ## Technical Architecture ## Troubleshooting **Cause**: Merchant workspace hasn't completed Stripe onboarding. **Solution**: Navigate to Settings → Stripe and complete the account connection flow. **Cause**: Deployment workflow encountered a non-retryable error. **Solution**: Check your cluster status and contact CNAP support for assistance. ## Future Enhancements The following improvements are planned: 1. **Payment Hold Flow**: Authorize payment before deployment, capture only after success 2. **Automated Refunds**: Automatically refund customers if deployment fails 3. **Ownership Transfer**: Update Stripe customer metadata when workspace owner changes 4. **Enhanced Monitoring**: Dashboard for stuck deployments and payment issues 5. **Webhook Async Processing**: Return 200 immediately, process deployment asynchronously Have feedback on the payment system? [Discuss on Discord](https://cnap.tech/discord)! # GitHub Integration Source: https://docs.cnap.tech/platform/github-integration Connect GitHub accounts and organizations to access repositories and enable automated deployments # GitHub Integration Connect your GitHub accounts and organizations to CNAP for seamless repository access and automated deployments. Our GitHub App integration provides secure, scoped access to your repositories without requiring personal access tokens. Connect your personal GitHub account for individual projects Add GitHub organizations for team collaboration ## Benefits * **Secure Authentication** - GitHub App provides secure, scoped access without personal tokens * **Team Collaboration** - Share GitHub access across all workspace members * **Multiple Sources** - Connect both personal and organization accounts in one workspace * **Automated Deployments** - Deploy directly from GitHub with Nixpacks auto-detection * **Granular Permissions** - Control exactly which repositories are accessible ## How It Works ### 1. Install GitHub App When you connect a GitHub account or organization, CNAP requests permission to install our GitHub App. This creates a secure connection that doesn't require storing personal access tokens. CNAP Dashboard showing application catalog and marketplace ### 2. Select Repository Access Choose which repositories to make available to your workspace. You can grant access to: * **All repositories** (current and future) * **Selected repositories** (specific repos only) * **Public repositories only** (for open source projects) ### 3. Workspace Integration Once connected, all workspace members can: * Deploy applications from connected repositories * Access repository contents for building and deployment * View repository metadata and commit history Successful GitHub App installation confirmation ## Personal Accounts Connect your personal GitHub account to access your individual projects and repositories. ### Benefits * **Individual Projects** - Deploy your personal side projects and experiments * **Open Source** - Contribute to and deploy open source applications * **Learning** - Practice with your own repositories without organizational constraints * **Portfolio** - Showcase your work through deployed applications ### Use Cases * Personal blogs and websites * Side project APIs and services * Open source contributions * Learning and experimentation ## Organizations Connect GitHub organizations to enable team collaboration and access to shared repositories. ### Benefits * **Team Access** - All workspace members can use organization repositories * **Shared Resources** - Collaborate on company projects and client work * **Scalable** - Add multiple organizations to one workspace * **Flexible** - Mix personal and organizational repositories ### Use Cases * **Agencies** - Connect multiple client organizations * **Companies** - Access internal tools and applications * **Open Source** - Contribute to organization projects * **Consulting** - Manage different client repositories ## Security & Permissions * **Repository contents** - For building and deployment purposes * **Repository metadata** - Name, description, language, and structure * **Commit history** - For deployment tracking and versioning * **Branch information** - To understand repository structure * **Private repository contents** - Unless explicitly granted access * **User personal information** - Email, profile data, or private details * **Organization settings** - Billing, member management, or admin settings * **Other applications** - Access to other GitHub Apps or integrations * **Repository access** - Only repositories you explicitly grant * **Read-only by default** - Cannot modify your code or settings * **Temporary tokens** - Short-lived access tokens for security * **Revocable** - You can revoke access at any time ## Multiple Installations CNAP supports multiple GitHub App installations within a single workspace, enabling flexible access patterns: ### Supported Configurations * **Multiple Personal Accounts** - Add different team members' personal accounts * **Multiple Organizations** - Connect various client or company organizations * **Mixed Access** - Combine personal and organizational repositories * **Team Collaboration** - All workspace members can use all connected installations ### Example Scenarios ``` Workspace: "My Consulting Business" ├── Personal Account (alice-dev) ├── Client A Organization (acme-corp) └── Client B Organization (startup-xyz) ``` Access repositories from all sources in one workspace. ``` Workspace: "Engineering Team" ├── Company Organization (mycompany) ├── Open Source Org (mycompany-oss) └── Team Lead Personal (lead-dev) ``` Combine company resources with open source contributions. ``` Workspace: "Digital Agency" ├── Agency Organization (digital-agency) ├── Client A (client-a-corp) ├── Client B (client-b-inc) └── Partner Org (partner-company) ``` Manage all client projects from one workspace. ## Repository Deployment Once GitHub accounts are connected, you can deploy applications directly from repositories: ### Automatic Detection CNAP uses Nixpacks to automatically detect your application type and build configuration: * **Node.js** - Express, Next.js, SvelteKit, Remix, Nuxt * **Python** - Django, FastAPI, Flask * **Go** - Gin, Echo, Chi * **Ruby** - Rails, Sinatra * **Java** - Spring Boot, Quarkus * **Rust** - Actix, Rocket, Axum * **PHP** - Laravel, Symfony ### Deployment Process 1. **Select Repository** - Choose from connected GitHub repositories 2. **Auto-Detection** - Nixpacks analyzes your code and determines build process 3. **Build & Package** - CNAP builds and packages your application 4. **Deploy** - Deploy to your selected clusters 5. **Configure** - Set pricing and make available as a product ## Best Practices **Start Simple** - Begin with one GitHub account and expand as needed **Repository Access** - Only grant access to repositories you want to deploy from CNAP ### Security Recommendations * **Principle of Least Privilege** - Grant access only to necessary repositories * **Regular Review** - Periodically review connected accounts and permissions * **Team Coordination** - Coordinate with team members before adding new installations * **Access Management** - Remove access for team members who leave the workspace ### Collaboration Tips * **Clear Naming** - Use descriptive names for different GitHub installations * **Documentation** - Document which repositories are used for which products * **Access Patterns** - Establish clear guidelines for repository access * **Regular Cleanup** - Remove unused installations to maintain security ## Troubleshooting * Verify the repository is included in the GitHub App installation * Check that the repository is not private (unless explicitly granted access) * Ensure the GitHub App has the necessary permissions * Try reconnecting the GitHub account * Check that your repository has a supported language/framework * Verify all dependencies are properly declared * Review build logs for specific error messages * Consider adding a Dockerfile for custom build requirements * Verify you have access to the repository * Check that the GitHub App installation is still active * Ensure the repository hasn't been moved or deleted * Try refreshing the GitHub connection ## Next Steps Start by connecting your first GitHub account Learn how to deploy applications from GitHub repositories Organize your GitHub installations within workspaces Learn about CNAP's security model and best practices # Products Source: https://docs.cnap.tech/products Learn how to host your software product Products describe the specific service you offer to your customers. For example, you might offer a monthly subscription to host a dedicated deployment of your software. CNAP simplifies the technical complexity of creating sellable products from your software. You define what customers receive (Helm charts, configurations, pricing), and CNAP manages deployment, billing integration, and infrastructure orchestration across your clusters of machines. ### Creating a Product Onboard your product through the [Products Dashboard](https://dash.cnap.tech/products?create=product). adding a product You can select the Helm package from Artifact Hub. Our roadmap includes support for Helm charts hosted on private Git/OCI repositories in the near future. Select to which clusters the product can be deployed. Users will only see the regions of the clusters when they are deploying the product. Checkout [Clusters](/clusters) for more information. ### Pricing products If you require users to pay for deployments of a product, you can link a CNAP product with one or more Stripe prices from one or more Stripe products. Make sure to connect with Stripe in the [Settings](https://dash.cnap.tech/settings/stripe) of your workspace to onboard with a Stripe account connected to CNAP. connect stripe Once Stripe is connected, you can associate Stripe prices with the CNAP product. empty prices Create a **Stripe product with prices** in the Stripe dashboard. stripe add product You can edit the Stripe product to add even more prices, e.g.: * €10/month subscription * €50 one-time setup fee stripe edit product As soon as the Stripe products and prices are created, they will be immediately loaded and available for selection in CNAP. price selection All prices you select for the CNAP product will apply when users checkout the product in the marketplace. You can also create more Stripe products and select their prices for the same CNAP product if you need to (e.g. a deployment consists of multiple services). Click "Add Product" to create the product. *** Congrats! You're set up to start your hosting, and it's batteries included! Need support or want to give some feedback? You can join our [Discord-Community](https://discord.gg/gNh9bUWVp7) or drop us an email at [support@cnap.tech](mailto:support@cnap.tech). # Quickstart Source: https://docs.cnap.tech/quickstart Sell and host your software in minutes Get your software products live and ready for customers in under 10 minutes. CNAP handles the infrastructure complexity so you can focus on what matters - building and selling great software. The interactive onboarding is the fastest path towards your first sale.