Quick Start

Deploy your first application in minutes:

1. Connect GitHub: Authenticate with GitHub OAuth to access your repositories.
2. Select Repository: Choose a repository from your GitHub account.
3. Configure Deployment: Set up networking, environment variables, and compute settings.
4. Deploy: Click deploy and watch your application go live.

What's Next?

Once you've deployed your first app, explore:

• Environment Configuration: Set up environments, variables, and compute settings
• Networking: Configure ports, protocols, and custom domains
• Observability: Monitor your applications with logs and signals
• API Reference: Complete API documentation
• Best Practices: Tips and patterns for building on 100X

Core Principles

100X is built on principles of simplicity, elegance, and correctness:

• Truth: Accurate representation of system state
• Beauty: Clean, intuitive interfaces
• Simplicity: Minimal complexity, maximum clarity
• Elegance: Graceful solutions to complex problems
• Correctness: Reliable and predictable behavior
• Curiosity: Continuous improvement and innovation

Elastic Cloud

100X provides an elastic cloud that scales in and out quickly based on demand. The platform starts with a small pool of infrastructure and scales dynamically as needed.

Technology Stack

Built on modern, reliable infrastructure:

• Hardware: Hetzner Cloud (US Servers only)
• Orchestration: Kamal for deployment and management
• SSL: Let's Encrypt for certificates

Core Entities

The 100X platform is built around several key entities:

• User: Authenticated users from GitHub OAuth
• Project: Top-level organizational unit grouping deployments and repositories
• Team: Groups of users working together (auto-created with projects)
• Repository: GitHub repositories connected to projects
• Deployment: Running instances of applications
• Compute: Runtime resources where deployments run
• Networking: Network configuration for deployments
• Environment: Environment variables and secrets

Key Relationships

Understanding how entities relate:

• Users own Projects and can be members of Teams
• Projects contain Repositories and Deployments
• Repositories are mapped to Templates for building
• Deployments run on Compute resources with Networking configuration
• Deployments generate Logs and Signals for observability

Lifecycle States

Deployments progress through these states:

1. Building: Container/image creation phase
2. Deploying: Build complete, rolling out
3. Deployed: Successfully deployed but may not be fully running
4. Running: Service is up and operational

Architecture

The build system follows an asynchronous worker pattern to keep the web layer responsive:

1. Trigger: User pushes to GitHub (Webhook) or manually deploys via UI
2. Queue: API sends a build job to a queue
3. Worker: Background Go routine picks up the job
4. Builder: Ephemeral process/container builds the image using Go Docker SDK
5. Registry: Final image is pushed to Docker Hub registry

Build Process

Each build follows these steps:

1. Clone: Worker clones the repository into a temporary directory
2. Detect & Template: If no Dockerfile exists, system detects language and generates one
3. Build: Uses Go Docker SDK with resource limits and isolation
4. Push: Image is tagged and pushed to Docker Registry

Security & Isolation

Builds are secured with:

• Resource Quotas: Strict RAM/CPU limits to prevent denial-of-service
• No Baked Secrets: Secrets are injected at runtime, never during build
• Timeouts: All build contexts have timeouts (e.g., 5 minutes)
• Ephemeral Environments: Builds run in isolated contexts

OAuth Flow

100X uses GitHub OAuth for authentication:

1. Login: User initiates login, system generates CSRF state and redirects to GitHub
2. Callback: GitHub redirects back with authorization code
3. Token Exchange: System exchanges code for OAuth token
4. User Fetch: System fetches GitHub user information
5. Session: JWT token is generated and stored in secure cookie

Scopes

100X requests the following GitHub scopes:

• read:user: Read user profile information
• user:email: Access user email addresses
• repo: Access public and private repositories

Security

Authentication is secured with:

• CSRF protection via state parameter
• HttpOnly cookies for token storage
• JWT tokens for session management
• Secure cookie flags in production (HTTPS)

Deployment Process

When creating a deployment, you configure:

• Template: The 100X template to use (inherited from repository or overridden)
• Networking: Port, protocol, public/private access, ingress, and load balancer settings
• Environment Variables: Key-value pairs available to the running service
• Compute Settings: Memory, vCPU, and auto-scaling configuration

Deployment States

Track your deployment through these states:

1. Building: Container image is being created
2. Deploying: Build complete, deployment in progress
3. Deployed: Successfully deployed but may not be fully running
4. Running: Service is up and operational

Repository Environments

Each repository can have multiple environments (e.g., production, staging, development) that define:

• Environment variables and secrets
• Compute resource settings
• Deployment-specific configurations

Compute Settings

Configure compute resources:

• Memory: Allocation in megabytes
• vCPU: Number of virtual CPUs
• Auto-scaling: Min/max instances for horizontal scaling
• Instance Type: Predefined or custom instance sizes

Coming Soon

Full API reference documentation is in development. Check back soon for detailed endpoint documentation, authentication methods, and code examples.

Domain Strategy

100X uses two primary domains:

• run100x.com: Primary domain focusing on infrastructure and execution
• ship100x.com: Companion domain for docs, marketing, and tutorials

Custom Domains

Configure custom domains for your deployments with automatic SSL certificate management via Let's Encrypt.