# Overview Source: https://docs.revolte.ai/Final Manage Revolte pricing across plan usage, AI credits, delivery operations, and managed infrastructure. This page explains how Revolte billing works for teams evaluating or operating the platform. Revolte pricing is built around delivery output rather than seat count. A growing engineering organization can add more developers without automatically multiplying software spend. Instead, pricing is tied to how many services Revolte manages and how much execution actually happens across AI workflows, build pipelines, logs, and cloud resources. This matters because Revolte is not only an AI assistant. It spans planning, code generation, pull request workflows, CI/CD orchestration, runtime environments, and observability. That means your bill can have more than one cost surface, and each surface should be understood independently. > Enterprise billing can follow a separate commercial structure depending on deployment model, compliance requirements, support expectations, or procurement boundaries. ## What this page covers Use this page to understand: * how Revolte pricing is structured * what credits mean in practice * what infrastructure billing includes * how to estimate likely monthly cost * what enterprise controls change commercially and operationally ### Pricing Structure Revolte pricing is best understood through three independent usage surfaces. #### AI Execution Reasoning and code generation. This includes model-driven work such as code generation, PR review, planning assistance, and deeper reasoning workflows. #### Delivery Operations Builds, runs, logs, and previews. This includes CI/CD runs, log ingestion and storage, deployment activity, and preview environment usage patterns. #### Runtime Infrastructure Managed cloud resources. This includes web services, databases, storage, cache, secrets, metrics, network egress, and other underlying cloud primitives. ### Understanding Credits Credits exist to make AI usage easier to package at the plan level. Free and Pro plans communicate bundled AI capacity through included Revolte credits, while deeper technical AI pricing can still be reasoned about at the model level using token-based reference tables. In practice, this means the platform gives teams a simpler top-level allowance while still allowing deeper technical accounting underneath. On the public pricing page, Free includes 5 Revolte credits and Pro includes 20 Revolte credits. The plan-facing mental model also notes that 1 credit is approximately 1K prompt tokens. For overages, the public PAYG rate is listed as \$0.20 per 1K AI tokens. ### What a credit helps simplify Credits abstract raw model usage into a platform-friendly unit so users do not need to think in token accounting first. This is useful for onboarding, plan comparison, and governance discussions. * small prompt or lightweight task = lower usage * PR review with reasoning = medium usage * Jira to implementation workflow = higher usage * large refactor or deep debugging = highest usage ### What actually drives AI consumption Usage grows when prompts get longer, more repository context is loaded, more code is generated, more review turns are requested, or higher-capability model families are selected. Repeated context can become cheaper when caching is used effectively. Good usage is focused execution with clear requirements, tighter repository scope, and the right model for the job, rather than always defaulting to the most expensive reasoning tier. | Consumption area | What usually increases it | How to keep it efficient | | ----------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | | Prompt input | Large task descriptions, excessive pasted context, broad repository scans | Use focused requirements, smaller task scopes, and precise repository context | | Model output | Large code generation, long explanations, repeated iterations | Constrain the desired output shape and ask for narrower, reviewable increments | | Premium reasoning | Using high-capability models for every task | Reserve premium models for architecture, deep debugging, and critical review paths | | Repeated context | Sending the same documents or system context over and over | Use caching where available so repeated context is read more cheaply than rewritten | ### Enterprise Controls Enterprise pricing is not only about discounting. It exists for teams that need deployment flexibility, compliance posture, support guarantees, usage governance, and modular procurement options. ### Commercial flexibility AI-only, platform-only, intelligence-only, or any combination of the three modules can be packaged. All three bundled together are positioned for maximum discount. ### Control and deployment model Enterprise capabilities include unlimited services and usage with custom caps, BYOC, private cloud, and on-prem deployment options. ### Assurance and support Custom SLA and uptime guarantees, dedicated customer success support, white-glove onboarding, migration support, SOC 2 and GDPR support, and a listed 4-hour priority support SLA. | Enterprise capability | Why it matters | | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | Unlimited services and custom caps | Lets larger organizations grow service count while still governing spend and consumption thresholds | | BYOC + private cloud / on-prem | Supports organizations with infrastructure, data residency, or security requirements beyond standard SaaS hosting | | SSO and RBAC | Improves access governance and aligns the platform with enterprise identity management practices | | SOC 2, GDPR, custom compliance support | Helps regulated buyers evaluate trust, governance, and procurement readiness | | Dedicated success manager and white-glove onboarding | Reduces rollout risk for platform adoption across multiple teams and services | | BYO LLM and custom fine-tuning support | Allows larger customers to control model strategy rather than being locked into a single default approach | ### FAQ ### Why is Revolte not priced per seat? Revolte pricing is aligned to managed services and actual execution rather than the number of developers who need access. This avoids automatic cost multiplication when engineering teams grow. ### Is AI usage the same as infrastructure billing? No. AI usage, delivery operations, and runtime infrastructure are separate cost surfaces and should be evaluated separately. ### What usually increases cost fastest? The main growth levers are repeated AI-heavy workflows, high CI/CD volume, rapid log growth, preview sprawl, and runtime infrastructure expansion across services. ### When should a team move to Enterprise? Enterprise becomes relevant when service count, compliance requirements, support expectations, deployment model requirements, or governance controls move beyond standard Pro boundaries. ### Next steps * Review plan and pricing assumptions against expected service count and workflow usage. * Estimate likely AI, CI/CD, and log overages before production rollout. * Add runtime infrastructure only for the services that will actually be deployed. # Create Your First Workflow Source: https://docs.revolte.ai/ai-workflows/development-workflow/get-started Follow this guide to activate repository-connected automation for your project. Launch your first AI-powered development workflow in minutes by connecting your Jira workspace and defining your automation rules. **Prerequisite**: Ensure your repository is connected to a Revolte application. Learn how in the [Get Started](/quick-start#onboarding-walkthrough) guide. Navigate to your application [integration settings](/integrations/project-management/jira). Under **Jira Configuration**, select **Configure Workflow Automation** to begin the setup process. Go to the **Automation Configurations** tab. If no workflows are active, you will see the initialization screen. Click **Configure Automation**. Define how Revolte should interact with your Jira statuses. * **Action**: Select `Developer workflow`. * **Mapping**: Choose which statuses trigger development (e.g., *To Do* to *In Progress*) and completion (e.g., *Done*). * **Target Branch**: Specify the branch where AI changes should be proposed (e.g., `qa` or `main`). Once saved, your new workflow will appear in the active configurations list, showing the branch mapping and status flow. To trigger the workflow for a specific task, open the ticket in Jira and locate the **Revolte** section in the right sidebar. Under **Select Application**, select your target application service from the dropdown menu. See the [Jira Integration Guide](/integrations/project-management/jira#triggering-workflows-from-jira) for detailed integration steps. Selecting the application instantly triggers the AI agent workflow. The sidebar updates to display a **Workflow Triggered** success status. Click the **View Workflow Details** button to jump directly into the live agent execution dashboard. Switch back to the Revolte dashboard under **Agent runs** to see the real-time status of your workflow. Once complete, drill down into the run to see the execution stages, including Sandbox Provisioning, Code Setup, and Token Usage statistics. Navigate to the **Artifacts** tab to review the AI-generated implementation plan, including sub-tasks and proposed file changes. Finally, use the **Diff Summary** tab to inspect every line of code modified or created by the agent before finalizing the delivery. Once the agent finishes, it automatically opens a Pull Request on GitHub (or your configured Git provider) so you can review and merge the proposed changes. After merging, you can deploy the changes to a preview environment. Click **View Preview** and confirm the deployment using your [`revolte.yml`](/yaml/overview) configuration. ## Next steps * [Overview of Development Workflows](/ai-workflows/development-workflow/overview) * [Quality Assurance Gates](/ai-workflows/quality-assurance) Coming Soon * [Product Strategy Automation](/ai-workflows/product-strategy) Coming Soon # Development Lifecycle Source: https://docs.revolte.ai/ai-workflows/development-workflow/overview Automate task execution and delivery cycles with AI-assisted workflows and risk-based gates. Development workflows in Revolte bridge the gap between task management and code delivery. By connecting your task tracker (Jira) and Git provider, you can automate the entire lifecycle—from initial implementation to preview deployment. ## Core capabilities Revolte provides a dual-layered approach to development automation: ### 1. AI agent workflows Transform Jira tickets into pull requests automatically. The AI agent analyzes your task context, generates an implementation plan, and executes code changes within a secure sandbox. * **Auto-Implementation**: Generate code based on Jira descriptions and labels. * **Artifact Generation**: Review AI-generated implementation plans and diff summaries. * **Jira Integration**: Trigger workflows directly from your task sidebar. ### 2. Git-based automation Control the quality and speed of delivery using repository-level events and policy-driven gates. * **Risk Scoring**: Automatically score every PR based on file sensitivity and service criticality. * **Review Gates**: Enforce approval requirements based on risk levels defined in your `revolte.yml`. * **Preview Deployments**: Spin up isolated environments for every change to validate behavior. ## How it works The workflow typically follows these key stages: A task is opened in Jira, and the developer selects the target application service from the **Revolte** sidebar dropdown. This instantly signals the AI agent to begin the delivery cycle. The AI agent creates a sandbox environment, analyzes the codebase, and produces an implementation plan. It then executes the changes and validates them against your existing architecture. A Pull Request is opened. Revolte calculates a **Risk Score** and applies the necessary review gates. Higher-risk changes (e.g., database migrations) require more strict approval policies. Once validated, you can deploy to a preview environment for final UAT before merging the changes into your main branch. ## Next steps * [Get Started](/ai-workflows/development-workflow/get-started) — Follow the step-by-step guide to activate your first workflow. * [YAML Reference](/yaml/overview) — Learn how to configure risk thresholds and service roots. # Understanding AI Workflows Source: https://docs.revolte.ai/ai-workflows/overview Leverage AI Workflows to automate your delivery loop from intent to production. **AI Workflows** provide the autonomous coordination layer for modern software delivery. By bridging the gap between intent and production, they handle the end-to-end execution of validation, risk scoring, and environment promotion—allowing engineering teams to scale velocity while maintaining absolute control. ## Workflow modules Tailor AI automation to every role in your engineering organization: } href="/ai-workflows/development-workflow/overview"> Accelerate delivery with automated code summaries, risk scoring, and intelligent PR reviews. } href="/ai-workflows/quality-assurance"> Automated test generation, regression analysis, and environment validation. } href="/ai-workflows/product-strategy"> AI-driven requirement analysis, ticket summarization, and roadmap mapping. ## The automated delivery loop | Stage | Manual SDLC | Revolte AI Workflow | | :----------- | :--------------------------------- | :------------------------------- | | **Analysis** | Manual ticket mapping & review | **Automated Intent Discovery** | | **Testing** | Human-triggered test runs | **Predictive Validation** | | **Review** | Time-consuming manual diff checks | **AI-Powered Code Summaries** | | **Release** | Manual promotion & gate checks | **Automated Risk-Based Gating** | | **Feedback** | Reactive monitoring & post-mortems | **Continuous Learning & Tuning** | **Governance by Design**: While AI Workflows automate the work, you remain in control. All automation follows your organization's compliance policies and requires explicit approval for critical production paths. ## Next steps * [Get Started with Development Workflows](/ai-workflows/development-workflow/overview) # AI Product Planning Source: https://docs.revolte.ai/ai-workflows/product-strategy AI-driven requirement analysis, ticket summarization, and roadmap mapping. **Coming Soon**: We are currently finalizing the Product Strategy workflow module. Stay tuned for future updates and release notes. AI-native product engineering will allow teams to: * Automatically analyze and summarize complex requirements. * Map development progress directly to roadmap milestones. * Generate high-fidelity ticket summaries and impact reports. *** ## Quick Links Explore how Revolte automates software implementation. # Automated Quality Validation Source: https://docs.revolte.ai/ai-workflows/quality-assurance Automated test generation, regression analysis, and environment validation. **Coming Soon**: We are currently finalizing the Quality Assurance workflow module. Stay tuned for future updates and release notes. AI-native quality engineering will allow teams to: * Automatically generate test cases based on commit intent. * Execute regression suites prioritized by change risk. * Validate environment stability before promotion. *** ## Quick Links Explore how Revolte automates software implementation. # Install & Start Using CLI Source: https://docs.revolte.ai/cli/quick-start Set up your first project and initiate development workflows using the Revolte CLI. The Revolte CLI enables you to move from intent to code in seconds. Follow this guide to set up and trigger your first autonomous workflow. **Prerequisite**: Ensure your repository is connected to a Revolte application. Learn how in the [Get Started](/quick-start#onboarding-walkthrough) guide. Install the Revolte CLI globally using npm. ```bash Terminal theme={"dark"} npm install -g @revolte.ai/cli ``` Log in to connect your local environment with the Revolte AI. Running this command will open a browser window for you to complete the authentication securely. ```bash Terminal theme={"dark"} revolte --login ``` Once you log in through the browser, your terminal session will be automatically updated with the necessary credentials. Open the Revolte CLI in your project directory. You can enter any natural language prompt to describe the task you want to execute. ```bash Terminal theme={"dark"} revolte --start ``` Add a contact form component to the landing page with email validation. Fix the session invalidation bug in the authentication middleware. Once you hit **Enter**, Revolte AI begins analyzing your project context. Revolte AI starts working directly in your local directory. It automatically identifies the necessary files, applies the changes, and ensures everything aligns with your existing architecture. If the tool requests permission to modify specific files, simply review the plan and approve it to proceed. Once the task is complete, review the generated code locally. If you're satisfied with the results, commit and push the changes to your repository. ```bash Terminal theme={"dark"} git add . git commit -m "feat: added contact form via Revolte AI" git push origin main ``` *** ## Next steps * [CLI Reference](/cli/reference) * [Configuration Overview](/yaml/overview) # CLI Command Reference Source: https://docs.revolte.ai/cli/reference Detailed technical reference for Revolte CLI requirements, commands, and global options. The Revolte CLI is designed to be a lightweight but powerful interface for managing your AI-native development workflows. Use this reference to understand system requirements and the full command suite. ## System requirements Ensure your local environment meets these minimum specifications before installing the Revolte CLI. | Requirement | Minimum | Notes | | ----------- | ------------------ | --------------------------------------------------------- | | Node.js | 20 | Required for npm installation and many JavaScript builds. | | Git | 2.40 | Required for repository-aware workflows. | | Shell | bash, zsh, or fish | Used by install scripts and command examples. | | Network | HTTPS access | Required for Revolte API and provider integrations. | ## Installation If you haven't installed the CLI yet, run the following command globally: *** ## Command reference | Command | Purpose | | ------------------- | -------------------------------------------------------- | | `revolte --start` | Start the Revolte AI workflow in your current directory. | | `revolte --login` | Authenticate the CLI with your Revolte account. | | `revolte --help` | Show help for all commands. | | `revolte --version` | Show the current version of the CLI. | Use `revolte --help` to get more details about a specific command's arguments and flags. # DORA Metrics Source: https://docs.revolte.ai/dashboard/dora Monitor your team's software delivery performance using industry-standard DORA metrics. The Revolte Dashboard provides a comprehensive view of your software delivery lifecycle through **DORA (DevOps Research and Assessment)** metrics. These metrics help teams measure their velocity, stability, and overall effectiveness. DORA Dashboard ## Key metrics Revolte automatically tracks the four key DORA metrics across your production services. ### 1. Deployment frequency **How often the organization successfully releases to production.** High-performing teams aim for frequent, smaller deployments to reduce risk and deliver value faster. ### 2. Lead time for changes **The time from commit to deployment to production.** This metric highlights bottlenecks in your development and deployment pipeline. ### 3. Change failure rate **The percentage of deployments causing production failures.** A lower rate indicates more stable releases and robust testing processes. ### 4. Mean time to recovery **The average time to resolve production issues.** This metric reflects your team's ability to respond to incidents and restore service quickly. *** ## Performance insights Beyond the core DORA metrics, the dashboard provides granular insights into your build and deployment health. Track the percentage of successful builds. High success rates indicate a stable CI process. Monitor the reliability of your deployments as they move to production. ### Build vs deployment trends The dashboard includes a detailed timeline of **Builds vs Deployments**, allowing you to visualize: * **Success vs Failure**: Identify patterns in build or deployment failures. * **Volume Correlation**: See how build frequency correlates with deployment volume over time. *** ## Using the dashboard Access the DORA Dashboard from your Revolte workspace to: * **Filter by Environment**: Switch between `production`, `qa`, and other environments to see stage-specific metrics. * **Time Range Selection**: Analyze performance across specific months or custom timeframes. * **Service-Level Insights**: Drill down into metrics for individual web applications and services. Consistent monitoring of DORA metrics is the first step toward building a high-performing engineering culture. Use these insights to drive process improvements and automate bottlenecks. # Code Maintainability Insights Source: https://docs.revolte.ai/dashboard/maintainability Track code smells, technical debt, and complexity metrics to ensure long-term codebase health. **Coming Soon**: We are currently finalizing the Maintainability dashboard. Stay tuned for future updates and release notes. # Engineering Insights Dashboard Source: https://docs.revolte.ai/dashboard/overview A centralized hub for monitoring project health, performance, and development velocity. The Revolte Dashboard serves as your central command center for project observability. It provides real-time insights into your delivery performance and system health, enabling data-driven decisions across your development lifecycle. ## Active dashboards ### DORA metrics Monitor your team's software delivery performance with industry-standard DORA metrics. Gain visibility into deployment frequency, lead time for changes, stability, and recovery speed. [Explore DORA Metrics](/dashboard/dora) *** ## Future roadmap We are continuously expanding our observability suite to provide a 360-degree view of your software development. The following dashboards are currently under development: }> Monitor vulnerabilities, security hotspots, and compliance across your repositories in real-time. }> Track code smells, technical debt, and complexity metrics to ensure long-term codebase health. }> Gain insights into development velocity, PR cycle times, and team collaboration patterns. Interested in early access to these features? Contact our support team to join the beta program. # Engineering Productivity Insights Source: https://docs.revolte.ai/dashboard/productivity Gain insights into development velocity, PR cycle times, and team collaboration patterns. **Coming Soon**: We are currently finalizing the Productivity dashboard. Stay tuned for future updates and release notes. # Security Posture & Governance Source: https://docs.revolte.ai/dashboard/security Monitor vulnerabilities, security hotspots, and compliance across your repositories in real-time. **Coming Soon**: We are currently finalizing the Security dashboard. Stay tuned for future updates and release notes. # Monitor Application Logs Source: https://docs.revolte.ai/deployments/observability/application-logs Stream, filter, and search stdout and stderr from running Revolte services. Application Logs ## How to use Follow these steps to explore and analyze your service logs in the Revolte dashboard. Use our intuitive query builder to filter by environment, service, log level, or custom text patterns. Toggle **Live Stream** to watch logs as they are emitted from your running instances. Download filtered log sets as CSV or JSON for external auditing or post-mortem analysis. ## Quick links * [Deployment Logs](/deployments/observability/deployment-logs) * [Insights](/deployments/observability/insights) * [Rollbacks](/deployments/rollbacks) # View Deployment Logs Source: https://docs.revolte.ai/deployments/observability/deployment-logs Inspect build and deploy pipeline output with stage context and error highlighting. Deployment Logs ## Monitoring workflow Push code to a linked branch or trigger a manual deploy from the dashboard. The deployment log viewer opens automatically, showing the live output from the current stage. Once complete, review the full log history or use the error highlighter to find specific issues. ## Quick links * [Application Logs](/deployments/observability/application-logs) * [Past Deployments (Rollbacks)](/deployments/rollbacks) # Overview Source: https://docs.revolte.ai/deployments/observability/index Monitor deployments with logs and runtime insights. Observability helps monitor deployments, runtime behavior, and application health across Revolte services. ## Signals * [Deployment Logs](/deployments/observability/deployment-logs) — Build, deployment, and health check logs. * [Application Logs](/deployments/observability/application-logs) — Runtime logs emitted by applications and services. * [Insights](/deployments/observability/insights) — AI-generated anomalies and deployment recommendations. ## Related * [Services](/deployments/services/overview) * [Rollbacks](/deployments/rollbacks) * [Insights](/deployments/observability/insights) # Operational Insights Source: https://docs.revolte.ai/deployments/observability/insights Use AI anomaly detection, trends, and recommendations after deployment. Revolte Insights combines raw resource monitoring with AI-driven analysis to give you a complete picture of your application's health. Insights Dashboard ### Monitored metrics | Category | Available Metrics | | --------------- | ------------------------------------------------------- | | **Compute** | CPU Utilization, Load Average, Memory Usage, Swap Usage | | **Storage** | Disk Read, Disk Write, Disk Usage, Disk I/O | | **Networking** | Network In, Network Out, Connection Count | | **Reliability** | Request Rate, Error Rate (4xx/5xx), Success Rate | | **Latency** | Average Latency, p95 Latency, p99 Latency | ## AI recommendations Coming Soon ## Quick links * [Deployment Logs](/deployments/observability/deployment-logs) * [Application Logs](/deployments/observability/application-logs) * [Rollbacks](/deployments/rollbacks) # Deployment Lifecycle Source: https://docs.revolte.ai/deployments/overview Understand the Revolte deployment lifecycle and environments. Revolte simplifies the software delivery process by providing a unified deployment workflow across all your services and infrastructure. **Prerequisite**: Ensure your repository is connected to a Revolte application. Learn how in the [Get Started](/quick-start#onboarding-walkthrough) guide. ## Environments Revolte supports four standard environments for every project, allowing you to manage your application lifecycle from development to production: * **Production**: The live environment serving your end users. * **Staging**: A pre-production environment for final validation and testing. * **QA**: An environment dedicated to quality assurance and automated testing. * **Preview**: Ephemeral, dynamic environments automatically spun up for active feature branches. These feature a default 3-day retention period Customizable . **How to Customize Preview Expiry:** By default, Preview environments automatically destroy themselves after 3 days. To adjust this lifespan: 1. Open your project dashboard and select **Settings** from the left navigation bar. 2. Navigate to **General Settings** > **Preview environment expiry**. 3. Enter your preferred duration, select the unit (**Day** or **Hour**), and click **Update**. *Note: This applies to upcoming deployments only.* To configure how your Git branches map to these environments, see [App & Branch Settings](/yaml/repo-preferences/app-branch-settings). ## Related * [Services](/deployments/services) * [Observability](/deployments/observability/index) * [Rollbacks](/deployments/rollbacks) # Pipeline Execution Flow Source: https://docs.revolte.ai/deployments/pipeline Monitor deployment execution and manage manual gates. The **Pipeline** view in the Deployments tab provides real-time visibility into your software delivery process. It allows you to track the progress of every stage, from build to production promotion.
## Execution monitoring While pipelines are defined in [Repo Preferences](/yaml/repo-preferences/pipelines/overview), the Deployments tab is where you monitor their real-time execution and results. * **Stage Tracking**: View the status of Code Quality, Test Suite, and Build stages. * **Real-time Logs**: Stream logs directly from the pipeline runner to debug failures instantly. * **Execution History**: Access previous pipeline runs to compare performance and track changes. ## Manual gates & approvals For sensitive environments, pipelines can be configured with manual gates through your repository's [YAML Pipeline Config](/yaml/repo-preferences/pipelines/overview).
* **Approval Requests**: When a pipeline reaches a manual gate, designated team members are notified to review and approve the promotion. * **Audit Logs**: Every approval or rejection is logged with the user's details and timestamps for compliance. * **Environment Promotion**: Once approved, the pipeline automatically proceeds with the deployment to the target environment. ## Related * [Observability](/deployments/observability/index) * [Rollbacks](/deployments/rollbacks) * [YAML Pipeline Config](/yaml/repo-preferences/pipelines/overview) # Rollback Strategy Source: https://docs.revolte.ai/deployments/rollbacks Recover services by comparing past deployments and restoring known good versions. ## One-click revert The fastest way to recover is to select a previous deployment from your history and promote it back to production.
Go to the **Deployments** tab in your project dashboard to see the timeline of all releases. Identify a "Healthy" deployment from the list that you wish to restore. Click the **Revert to this version** button on the target deployment. Review the target version in the confirmation modal and click **Confirm**.
Revolte will immediately begin a rolling update to replace the current version with your selected target. ## Quick links * [Deployment Logs](/deployments/observability/deployment-logs) * [Observability Overview](/deployments/observability) * [Service Configuration](/deployments/services/overview) # Rollback Strategy Source: https://docs.revolte.ai/deployments/rollbacks/index Recover services by comparing past deployments and restoring known good versions. Rollbacks help teams recover when a deployment harms service health. Revolte keeps deployment history, configuration, logs, metrics, and review context together so operators can choose the safest recovery target. Browse release history, compare builds, and inspect deployment metadata. Follow an incident-ready rollback process from detection to verification. ## When to roll back | Signal | Rollback indicator | | ---------- | --------------------------------------------------------------- | | Error rate | User-facing failures exceed the service error budget. | | Latency | p95 or p99 latency regresses after release. | | Logs | New fatal errors or missing configuration appears after deploy. | | Insights | AI anomaly recommends pausing or reverting the rollout. | Confirm database and queue compatibility before rolling back application code. Schema migrations and asynchronous jobs can make some rollbacks unsafe. ## Related Choose a known good deployment. Execute the rollback safely. Gather the signals that justify recovery. # Configure Cache Services Source: https://docs.revolte.ai/deployments/services/cache Provision Redis and Memcached with persistence, clustering, and service bindings.
## Dashboard configuration You can configure your cache services directly through the Revolte dashboard: Select the application you wish to configure from your workspace. Click on the **YAML Configuration** tab in the top navigation bar. Select **Environment Settings** from the left sidebar. Locate and select the **Build & Deployment Workflow** section. Click on **Cache** to provision a new instance or modify existing settings. ## Example configuration Define your cache service in `revolte.yaml` to control versions, persistence, and clustering. ## Related * [Databases](/deployments/services/databases/overview) * [Web Services](/deployments/services/web-services) * [Environment Settings](/yaml/environment-settings/services) * [Secrets](/deployments/services/secrets) # Schedule Cron Jobs Source: https://docs.revolte.ai/deployments/services/cron-jobs Run scheduled tasks with retries, failure alerts, and environment-scoped configuration. Cron jobs execute scheduled work inside a Revolte environment. Use them for cleanup tasks, report generation, cache warming, reconciliation, and periodic integrations. ## Before you start * Node.js `18+` ## Schedule syntax | Syntax | Runs | | :------------- | :------------------------ | | `0 3 * * *` | Every day at 03:00 UTC | | `*/15 * * * *` | Every 15 minutes | | `0 */6 * * *` | Every 6 hours | | `0 9 * * MON` | Every Monday at 09:00 UTC | Schedules use UTC by default. Store timezone-specific behavior in the command or application code when business rules require it. ## Configuration Define your cron job in `revolte.yaml` to control schedules, commands, and retry behavior. ## Related * [Deployment Logs](/deployments/observability/deployment-logs) * [Application Logs](/deployments/observability/application-logs) * [Secrets](/deployments/services/secrets) # Database Explorer Source: https://docs.revolte.ai/deployments/services/databases/connect Connect to your databases, execute live queries, and manage saved snippets through the Revolte dashboard. ## Dashboard connection guide Select your application, navigate to the **Overview** tab, and click the **Connect** button in the top-right corner. Write your query and click **Run** to fetch live data. Save your queries for future use.
Review and manage your previously saved queries. # Manage Databases Source: https://docs.revolte.ai/deployments/services/databases/overview Provision PostgreSQL, MySQL, and MongoDB services with backups and connection policies. ## Supported engines | Engine | Description | | ---------- | -------------------------------------------------------- | | PostgreSQL | Recommended relational database for most applications | | MySQL | MySQL-compatible relational workloads | | MongoDB | Flexible document-based storage Coming Soon |
## Example configuration Define your database service in `revolte.yaml` to configure engines, versions, storage, and backup policies manually. ## Deployment templates Preconfigured deployment patterns for database-backed services. * [Web Service + Database](/guides/deployments/database) * [Web Service + Database + Cache](/guides/deployments/cache) * [Web Service + Database + Storage Bucket](/guides/deployments/storage) * [Web Service + Database, Cache, and Storage Bucket](/guides/deployments/presets) ## Database Connection Injection Provisioning a database service (e.g., named `db` under your YML services configuration) automatically injects the corresponding connection credentials into the environment variables of all other services within the same environment. This requires no manual secret configuration. The following environment variables are automatically injected at runtime: ```yaml theme={"dark"} DATABASE_HOST: '#{db.dbUrl}' DATABASE_PORT: '#{db.dbPort}' DATABASE_USERNAME: '#{db.dbUsername}' DATABASE_PASSWORD: '#{db.dbPassword}' DATABASE_NAME: '#{db.dbName}' ``` *(Note: Replace `db` with the exact name of your database service as declared under `services` in your `revolte.yaml`)* ## Related * [Database Explorer](/deployments/services/databases/connect) * [Web Services](/deployments/services/web-services) * [Cache](/deployments/services/cache) * [Environment Settings](/yaml/environment-settings/services) * [Secrets](/deployments/services/secrets) * [Observability](/deployments/observability) # Manage Domains Source: https://docs.revolte.ai/deployments/services/domains Manage custom domains, SSL/TLS certificates, and edge routing for your applications. ## Managed domains Every service in Revolte is automatically assigned a system-generated domain (e.g., `service-name.revolte.io`). These domains are fully managed and secure by default, allowing you to preview and share your applications instantly. Managed Domains ## Custom domain mapping Click on **Add Domain** and enter your domain or subdomain (e.g., `app.yourcompany.com`).
Revolte will provide the necessary DNS records (CNAME or A records). Add these to your DNS provider. Once records are detected, Revolte automatically provisions SSL certificates and begins routing traffic. You can monitor the verification status and live stats directly from the dashboard. Domain Stats ## Edge routing features | Feature | Description | | :---------------- | :------------------------------------------------------ | | **Automatic SSL** | Managed Let's Encrypt certificates with auto-renewal. | | **Global CDN** | Edge caching and routing for low-latency delivery. | | **Redirects** | Configure root-to-www or custom path-based redirection. | | **HSTS** | Enforce secure HTTPS connections for all users. | ## Related * [Web Applications](/deployments/services/web-applications) * [Web Services](/deployments/services/web-services) * [Secrets](/deployments/services/secrets) # Explorer Source: https://docs.revolte.ai/deployments/services/object-storage/explorer View and manage objects stored in your buckets directly from the dashboard. ## Dashboard guide Navigate to your application, go to the **Services** tab, and select the **Storage Bucket** service you wish to explore. Click the **List Items** tab in the service dashboard to view your files. Upload files directly into the bucket and manage your existing objects. Organize your assets by creating folders to maintain a structured directory. ## Related * [Overview](/deployments/services/object-storage/overview) * [Local Access & Credentials](/deployments/services/object-storage/local-access) * [Web Services](/deployments/services/web-services) * [Secrets](/deployments/services/secrets) # Local Access & Credentials Source: https://docs.revolte.ai/deployments/services/object-storage/local-access Generate and manage access keys to connect your local applications to Revolte storage buckets. ## Dashboard guide Navigate to your application, go to the **Services** tab, and select your **Storage Bucket** service. Switch to the **Credentials** tab and click **Generate New Key** to create your access credentials.
Review, rotate, or revoke your active access keys from the credentials management list.
## Related * [Overview](/deployments/services/object-storage/overview) * [Explorer](/deployments/services/object-storage/explorer) * [Secrets](/deployments/services/secrets) # Manage Object Storage Source: https://docs.revolte.ai/deployments/services/object-storage/overview Use S3-compatible object storage with CDN delivery and access policies. ## Storage patterns | Pattern | Use for | | :----------------- | :------------------------------------------- | | **Private Bucket** | User uploads, exports, and internal backups. | | **Public CDN** | Static assets, images, and public downloads. |
## Example configuration Define your storage bucket in `revolte.yaml` to control access policies, CDN settings, and CORS rules. ## Related * [Explorer](/deployments/services/object-storage/explorer) * [Local Access & Credentials](/deployments/services/object-storage/local-access) * [Web Services](/deployments/services/web-services) * [Cron Jobs](/deployments/services/cron-jobs) * [Environment Settings](/yaml/environment-settings/services) * [Secrets](/deployments/services/secrets) # Overview Source: https://docs.revolte.ai/deployments/services/overview Deploy applications, infrastructure, and runtime workloads with Revolte services. Revolte supports both monolithic and distributed service architectures. **Plan Limits**: Your ability to create new services and environments depends on your plan (e.g., 3 services on Free, 25 on Pro). Monitor your real-time quota in **Workspace Settings > Billing**. ## Requirements * Node.js `20+` ## Supported architectures * Monolithic applications * Distributed microservices * Frontend platforms * Backend APIs * Worker processes * Scheduled workloads ## Service types * [Web Applications](/deployments/services/web-applications) — Frontend and full-stack applications with managed deployment workflows. * [Web Services](/deployments/services/web-services) — APIs, backend services, and internal runtime workloads. * [Cron Jobs](/deployments/services/cron-jobs) — Scheduled workloads and recurring background execution pipelines. * [Databases](/deployments/services/databases/overview) — Managed relational and document databases. * [Cache](/deployments/services/cache) — Low-latency caching services for applications and APIs. * [Object Storage](/deployments/services/object-storage/overview) — Assets, uploads, backups, and generated artifacts. * [Domains](/deployments/services/domains) — Custom domains, managed SSL/TLS, and edge routing. * [Secrets](/deployments/services/secrets) — Encrypted environment variables and runtime credentials. ## Related * [Observability](/deployments/observability) * [Rollbacks](/deployments/rollbacks) * [Environment Settings](/yaml/environment-settings/overview) # External Secrets Source: https://docs.revolte.ai/deployments/services/secrets/external-secrets Integrate third-party secret managers to centrally store and pull application credentials. Centralize credential authority by linking external secret management tools (such as HashiCorp Vault). The external secrets integration dynamically imports existing keys and passwords, allowing teams to safely reference them across all active services. ## Integration Workflow Connect your Vault provider in four steps: Click on **Extensions** in the left sidebar of the Revolte console. Locate **Vault** under the recommended integrations and select it. Open the **Select the provider** dropdown and choose your provider (e.g., `hashicorp vault`). Fill in the required authentication and access fields to establish a secure link. Revolte will pull your existing secrets automatically. Environment variables must be configured in your `revolte.yaml` configuration file to properly reference and inject the synchronized Vault secrets into your application services. *** ## Reference ### FAQ Yes. Connection metadata and secret values are stored under industry-standard AES-256 encryption using customer-isolated KMS keys. Revolte pulls credentials dynamically from the linked Vault during container build and deploy phases, ensuring running workloads use the latest active secrets. *** ## Related * [Secrets Overview](/deployments/services/secrets/overview) * [Revolte Secrets](/deployments/services/secrets/revolte-secrets) * [Web Services](/deployments/services/web-services) ### Support Policy For advanced assistance with private VPC configurations, enterprise cluster peerings, or custom vault providers, connect with our support engineers on our [Contact Page](https://revolte.ai/contact). # Configure Secrets Source: https://docs.revolte.ai/deployments/services/secrets/overview Secure, encrypt, and inject sensitive application credentials across your deployment pipelines. Revolte provides two distinct methods for managing and injecting sensitive credentials into your application containers: | Feature | Revolte Secrets | External Secrets | | :-------------------- | :-------------------------------- | :-------------------------------- | | **Authority** | Native Revolte Platform | Third-Party Secret Managers | | **Supported Engines** | Revolte KMS / Dashboard | HashiCorp Vault | | **Best For** | Application-specific variables | Centralized enterprise compliance | | **Injection Method** | Static `revolte.yaml` declaration | Dynamic runtime synchronization | **Prerequisite**: You must explicitly declare all target environment variables inside `revolte.yaml` to inject your native or external secrets into container scopes. Refer to the [Variables & Secrets YAML Guide](/yaml/environment-settings/resource-specifications/variables) for syntax specifications. *** ## Secret Management Types Explore the detailed configurations for each secret management pathway: Configure and inject native encrypted secrets directly through the Revolte dashboard and standard YAML environment files. Link centralized secret management engines like HashiCorp Vault to automate team-wide credential sync. *** ## Related * [Web Services](/deployments/services/web-services) * [Databases](/deployments/services/databases/overview) * [Environment Settings](/yaml/environment-settings/services) * [YAML Overview](/yaml/overview) # Revolte Secrets Source: https://docs.revolte.ai/deployments/services/secrets/revolte-secrets Manage encrypted environment variables, scoping, injection, and rotation.
## Dashboard configuration Manage your encrypted secrets directly through the Revolte dashboard: Select the application you wish to configure from your workspace. Click on the **YAML Configuration** tab in the top navigation bar. Choose **Secrets** from the left sidebar to view and manage your encrypted environment variables. Add new secrets by providing a key and value, or update existing references across your environments. ## Example configuration ## Related * [Secrets Overview](/deployments/services/secrets/overview) * [External Secrets](/deployments/services/secrets/external-secrets) * [Web Services](/deployments/services/web-services) * [Databases](/deployments/services/databases/overview) * [Environment Settings](/yaml/environment-settings/services) * [YAML Overview](/yaml/overview) # Deploy Web Applications Source: https://docs.revolte.ai/deployments/services/web-applications Deploy SSR, static, and edge web applications with framework-aware builds. Required: `Node.js 18+` · `Revolte CLI v1.12.0+` ## Supported runtimes | Framework | Modes | | --------- | ----------------- | | Next.js | Static, SSR, Edge | | Remix | SSR | | Vite | Static | | Astro | Static, SSR | | SvelteKit | Static, SSR | Revolte respects explicit repository configuration before applying framework detection defaults. ## Example configuration ## Deployment workflow Follow the [GitHub integration guide](/integrations/repository/github) to connect and validate application metadata. Follow the [YAML overview](/yaml/overview) to define the web application through YAML or the dashboard. Follow the [secrets and variables guide](/deployments/services/secrets) and the [domains guide](/deployments/services/domains) to configure environment variables, secrets, domains, and deployment settings. Follow the [deployment overview](/deployments/services/overview) to deploy. ## Related * [Secrets](/deployments/services/secrets) * [Domains](/deployments/services/domains) * [Deployment Logs](/deployments/observability/deployment-logs) * [Web Services](/deployments/services/web-services) # Deploy Web Services Source: https://docs.revolte.ai/deployments/services/web-services Deploy REST APIs, gRPC services, and backend microservices with scaling and release controls. ## Requirements * Node.js `18+` ## Example configuration Define your web service in `revolte.yaml` to control builds, scaling, and environment settings. ## Additional services Beyond standard web services, you can provision and manage your entire infrastructure stack in the same `revolte.yaml` file: * **Managed Databases**: Relational and document stores (e.g., MongoDB, PostgreSQL). * **Cron Jobs**: Scheduled background tasks and recurring execution. * **Managed Cache**: Low-latency Redis-compatible caching layers. * **Storage Buckets**: S3-compatible object storage for assets, uploads, and backups. ## Deploy with dependent services Create databases, caches, object storage, and secrets before the API starts. Reference dependency URLs through environment variables or secret bindings. Execute schema migrations before traffic shifts to the new deployment. Monitor deployment logs, application logs, and runtime metrics. ## Deployment templates Preconfigured deployment patterns for common backend architectures. * [Web Service](/guides/deployments/web-services) * [Web Service + Database](/guides/deployments/database) * [Web Service + Database + Storage Bucket](/guides/deployments/storage) * [Web Service + Cache](/guides/deployments/cache) * [Web Service + Database + Cache](/guides/deployments/cache) * [Web Service + Database, Cache, and Storage Bucket](/guides/deployments/presets) ## Related * [Databases](/deployments/services/databases/overview) * [Cache](/deployments/services/cache) * [Secrets](/deployments/services/secrets) * [Observability](/deployments/observability) * [Rollbacks](/deployments/rollbacks) # Cache Source: https://docs.revolte.ai/guides/deployments/cache Configure repository preferences and environment settings for a managed Redis cache. This guide explains how to configure a **Cache** resource in Revolte. Managed Redis caches are modular building blocks used for high-speed data retrieval and session management. ## Combined deployments If your application requires compute (API) alongside a cache, you should select one of the following presets during the **Choose a Preset** step: * **Webservice + Cache** * **Webservice + Database + Cache** * **Webservice + StorageBucket + Cache** * **Webservice + Database + StorageBucket + Cache** > **Note:** For all combined presets, the core configuration workflow is identical to a standard [Web Service](/guides/deployments/web-services). This guide focuses specifically on the supplemental **Cache** settings described below. Select the **Cache** tile for a standalone instance, or choose one of the combined presets listed above for integrated deployments. Cache tab — QA environment The **QA** environment tab is selected. You can define independent resource specifications for **Preview**, **QA**, **Staging**, and **Production**. The center panel shows the Cache form for the active environment: * **Service Name** — Enter a unique identifier for this cache instance (e.g., `app_cache`). * **Specifications** * **CPU & Memory** — Choose a compute tier that matches your caching workload. Available options: * `2 CPU and .5 GB Memory` * `2 CPU and 1.37 GB Memory` * `2 CPU and 3.09 GB Memory` * `2 CPU and 6.38 GB Memory` * `2 CPU and 13.07 GB Memory` * `4 CPU and 12.93 GB Memory` * `4 CPU and 26.32 GB Memory` * `8 CPU and 26.04 GB Memory` * `8 CPU and 52.82 GB Memory` * `16 CPU and 52.26 GB Memory` * `16 CPU and 105.81 GB Memory` * `32 CPU and 103.68 GB Memory` * `32 CPU and 209.55 GB Memory` * `48 CPU and 157.12 GB Memory` * `48 CPU and 317.77 GB Memory` * `64 CPU and 209.55 GB Memory` > **Tip:** Use a cache to store session data, frequently accessed database queries, or pre-rendered content to improve application response times. *** **Quick Reference:** * [Technical Cache Overview](/deployments/services/cache) * [Cache Resource Specifications](/yaml/environment-settings/resource-specifications/cache) # Cron Source: https://docs.revolte.ai/guides/deployments/cron Configure repository preferences and environment settings for a scheduled background job. This guide explains how to configure a **Cron** resource in Revolte. Cron jobs are modular building blocks used for recurring tasks and background processing. ## Combined deployments If your application requires compute (API) alongside a scheduled task, you should select one of the following presets during the **Choose a Preset** step: * **Webservice + Cron** * **Webservice + Database + Cron** * **Cron + Database** * **Cron + Cache** * **Cron + Database + Cache** > **Note:** For all combined presets, the core configuration workflow is identical to a standard [Web Service](/guides/deployments/web-services). This guide focuses specifically on the supplemental **Cron** settings described below. Select the **Cron** tile for a standalone instance, or choose one of the combined presets listed above for integrated deployments. Cron tab — QA environment The **QA** environment tab is selected. You can define independent schedules and resource specifications for **Preview**, **QA**, **Staging**, and **Production**. The center panel shows the Cron form for the active environment: * **Service Name** — Enter a unique identifier for this cron job (e.g., `daily_cleanup`). * **Entry Point** — The script or command that starts the task (e.g., `scripts/cleanup.js`). * **Specifications** * **CPU & Memory** — Choose a compute tier appropriate for the job's complexity. * **Storage value** — Disk space in GB allocated for the job's temporary files. * **Properties** * **Scheduler** — Define the execution frequency using standard cron syntax (e.g., `cron(0 0 * * *)` for daily at midnight). * **Pre Script** — Commands to run before the main task (e.g., installing dependencies or setting up data). > **Tip:** Test your cron expressions using a validator to ensure they trigger at the expected intervals before committing. *** **Quick Reference:** * [Technical Cron Overview](/deployments/services/cron-jobs) * [Cron Resource Specifications](/yaml/environment-settings/resource-specifications/cron) # Database Source: https://docs.revolte.ai/guides/deployments/database Configure repository preferences and environment settings for a managed database service. This guide explains how to configure a **Database** resource in Revolte. Databases are modular building blocks that can be deployed standalone or as part of a combined full-stack preset. ## Combined deployments If your application requires compute (API) alongside a database, you should select one of the following presets during the **Choose a Preset** step: * **Webservice + Database** * **Webservice + Database + StorageBucket** * **Webservice + Database + Cache** * **Webservice + Database + StorageBucket + Cache** > **Note:** For all combined presets, the core configuration workflow is identical to a standard [Web Service](/guides/deployments/web-services). This guide focuses specifically on the supplemental **Database** settings described below. Select the **Database** tile for a standalone instance, or choose one of the combined presets listed above for full-stack deployments. Database tab — QA environment The **QA** environment tab is selected. You can define independent resource specifications for **Preview**, **QA**, **Staging**, and **Production**. The center panel shows the Database form for the active environment: * **Service Name** — Enter a unique identifier for this database instance (e.g., `production_db`). * **Specifications** * **Engine Type** — Choose between supported database engines (e.g., `PostgreSQL`, `MySQL`). * **CPU & Memory** — Choose a compute tier for your database workload. Available options: * `2 CPU and 1 GB Memory` * `2 CPU and 2 GB Memory` * `2 CPU and 4 GB Memory` * `2 CPU and 8 GB Memory` * `4 CPU and 16 GB Memory` * `8 CPU and 32 GB Memory` * `16 CPU and 64 GB Memory` * `48 CPU and 192 GB Memory` * `96 CPU and 384 GB Memory` * **Storage value** — Disk space in GB allocated to the database (e.g., `50`). > **Tip:** Revolte automatically generates connection strings for your database and injects them as secrets into linked services. *** **Quick Reference:** * [Technical Database Overview](/deployments/services/databases/overview) * [Connecting to your Database](/deployments/services/databases/connect) # Service Presets Source: https://docs.revolte.ai/guides/deployments/presets Overview of all available deployment presets in Revolte. Revolte provides a variety of service presets tailored for different application architectures. No matter which preset you choose, the configuration process always follows the same simple, modular workflow. ## The universal workflow Deploying any service in Revolte follows three consistent steps: Select the preset that matches your application requirements (e.g., **Webservice + Database**). Within the [Environment Settings](/yaml/environment-settings/overview) module, fill in the configuration forms for each resource in your preset. You can define independent specifications for **Preview, QA, Staging, or Production** environments using the dedicated resource tabs. Provide a commit message and branch. Revolte will sync the configuration to your repository and trigger the deployment. ## Choosing the right preset Use the table below to identify the best preset based on your application's requirements: | If you need to deploy... | Recommended Preset | | :-------------------------------------------- | :------------------------------------------------ | | A frontend app (React, Next.js, static site) | **Webapp** | | A standard REST API or Microservice | **Webservice** | | A backend API with a SQL Database | **Webservice + Database** | | A backend with object storage (for uploads) | **Webservice + StorageBucket** | | A backend with Redis caching | **Webservice + Cache** | | An API with a database and object storage | **Webservice + Database + StorageBucket** | | An API with a database and Redis caching | **Webservice + Database + Cache** | | An API with object storage and Redis caching | **Webservice + StorageBucket + Cache** | | A full-stack API with DB, Storage, and Cache | **Webservice + Database + StorageBucket + Cache** | | A scheduled background task or cron job | **Cron** | | A scheduled task with database access | **Cron + Database** | | A scheduled task with Redis caching | **Cron + Cache** | | A task with both database and caching | **Cron + Database + Cache** | | A task with storage and caching | **Cron + StorageBucket + Cache** | | A full-stack task with DB, Storage, and Cache | **Cron + Database + StorageBucket + Cache** | ## Core presets These are the foundational service types in Revolte: * **Webapp** — Build & deploy static frontend applications (React, Next.js, etc.) instantly. * **Webservice** — Standard backend service for APIs, microservices, or long-running processes. * **Cron** — Automate tasks and background jobs on a recurring schedule. ## Combined presets For applications requiring compute alongside storage or caching, Revolte offers combined presets that allow you to configure multiple resources in a single workflow. ### Web service combinations * **Webservice + Database** — Backend service with a managed relational database. * **Webservice + StorageBucket** — Backend service with integrated object storage. * **Webservice + Cache** — Backend service with Redis caching for faster responses. * **Webservice + Database + StorageBucket** — Complete stack with compute, database, and storage. * **Webservice + Database + Cache** — High-performance stack with compute, database, and caching. * **Webservice + StorageBucket + Cache** — Backend service with storage and caching integrations. * **Webservice + Database + StorageBucket + Cache** — The full enterprise stack with all managed resources. ### Cron job combinations * **Cron + Database** — Scheduled tasks with database read/write support. * **Cron + Cache** — Automate tasks that require high-speed data access. * **Cron + Database + Cache** — Complex scheduled tasks with database and caching integration. * **Cron + StorageBucket + Cache** — File or data processing tasks with caching support. * **Cron + Database + StorageBucket + Cache** — Enterprise-grade scheduled tasks with full resource integration. *** **Next Steps:** * [Web App Deployment Guide](/guides/deployments/web-apps) * [Web Service Deployment Guide](/guides/deployments/web-services) * [Database Configuration Guide](/guides/deployments/database) # Quick Start Source: https://docs.revolte.ai/guides/deployments/quick-start Master the twin pillars of service delivery: Repository Preferences and Environment Settings. After creating your application in Revolte, the configuration phase ensures your services are aligned with your team's development workflows and infrastructure requirements. This guide provides a high-level overview of the two configuration modules you will use to govern how code moves from your repository to a running service. ## Prerequisites Before configuring your services, ensure you have: 1. [Connected your repository](/integrations/repository/github). 2. Completed the initial application setup. If you haven't, start with the [Quick Start Guide](/quick-start). ## The configuration lifecycle Configuration in Revolte is split into two distinct areas. Understanding this distinction is key to a governed deployment workflow. Defined once per application. This governs **how** Revolte interacts with your code—including branch mappings, AI agent workflows, and pre-build validation steps. Defined per deployment target. This governs **where** and **under what conditions** code runs—including secrets, resource specifications, and scaling rules for Preview, Staging, or Production. ## 1. [Repository Preferences](/yaml/repo-preferences/app-branch-settings) The **Repository Preference** tab is the control center for your automation. These settings apply globally to the application across all environments. ### AI agent workflows Enable autonomous developer workflows to accelerate delivery: * **Developer Agent**: Toggle on to allow the AI to proactively implement tickets and handle routine PR work. * **Pre-build Workflow**: Enable automated code summarization and fix suggestions. You can tune the **Comment Style** (Balanced, Concise, or Verbose) to match your team's review culture. ### Pipeline governance Standardize your quality gates before any code reaches a build stage: * **Code Quality**: Link your application to a specific code style framework. * **Test Suite**: Define the exact execution command (e.g., `npm test` or `pytest`) that must pass before a deployment is triggered. ## 2. [Environment Settings](/yaml/environment-settings/overview) While Repository Preferences stay the same, **Environment Settings** adapt to the needs of each deployment stage. * **Resource Scaling**: Assign different CPU and Memory specifications for Preview environments vs. Production. * **Secrets & Variables**: Manage encrypted credentials that are injected only at runtime for specific environments. * **Deployment Policy**: Configure manual approval gates for sensitive environments to ensure human-in-the-loop governance. ## Why configuration matters * **Standardization**: Ensure every service follows the same validation and review lifecycle. * **Security**: Isolate sensitive credentials and control access through environment-specific target settings. * **Velocity**: Use AI agents and pre-build workflows to remove manual bottlenecks in the SDLC. ## Next steps Deep dive into branch mapping and agent workflows. Learn how to manage per-environment overrides and secrets. # Storage Bucket Source: https://docs.revolte.ai/guides/deployments/storage Configure repository preferences and environment settings for cloud object storage. This guide explains how to configure a **Storage Bucket** resource in Revolte. Storage buckets are modular building blocks used for object storage, uploads, and asset delivery. ## Combined deployments If your application requires compute (API) alongside object storage, you should select one of the following presets during the **Choose a Preset** step: * **Webservice + StorageBucket** * **Webservice + Database + StorageBucket** * **Webservice + StorageBucket + Cache** * **Webservice + Database + StorageBucket + Cache** > **Note:** For all combined presets, the core configuration workflow is identical to a standard [Web Service](/guides/deployments/web-services). This guide focuses specifically on the supplemental **Storage Bucket** settings described below. Select the **Storage Bucket** tile for a standalone instance, or choose one of the combined presets listed above for full-stack deployments. Storage Bucket tab — QA environment The **QA** environment tab is selected. You can define independent configurations for **Preview**, **QA**, **Staging**, and **Production**. The center panel shows the Storage Bucket form for the active environment: * **Service Name** — Enter a unique identifier for this storage service (e.g., `app_assets`). * **Configurations** * **Bucket Name** — A unique name for your storage bucket. * **Bucket Versioning** — Enable to keep multiple versions of an object in the same bucket. * **Enable Public Access** — Toggle to allow public read access to objects via URL. * **CORS Rules** — Define cross-origin resource sharing rules to allow web applications to access bucket contents safely. > **Tip:** Use public access only for files intended for direct browser consumption, like images or CSS assets. *** **Quick Reference:** * [Technical Storage Overview](/deployments/services/object-storage/overview) * [Storage Explorer](/deployments/services/object-storage/explorer) * [Local Access & SDKs](/deployments/services/object-storage/local-access) # Web App Source: https://docs.revolte.ai/guides/deployments/web-apps Configure repository preferences and environment settings for a frontend application. This guide explains how to configure a Web App as your next service in Revolte, covering both Repo Preference and Environment Settings. Visual references are provided for each step. Choose Web App Preset The preset chooser shows a grid of service options. The **Webapp** tile is highlighted, described as a standard service for frontend applications (React, Next.js, Vite, etc.). Click **Web App** to continue. The Repo Preference tab is identical across all service presets. See [Repository Preference](/yaml/repo-preferences/overview) for a full walkthrough of each setting. Web App tab — QA environment The **QA** environment tab is selected. You can define independent resource properties for **Preview**, **QA**, **Staging**, and **Production**. The center panel shows the Web App form for the active environment: * **Service Name** — Enter a unique identifier for this service (e.g., `frontend_app`). * **Entry Point** — The main file that starts the service (e.g., `index.js`). * **Properties** * **Index Page** — The default page served for the root path (e.g., `index.html`). * **Error Page** — The page served for 404 or other errors (e.g., `index.html` for SPAs). * **Enable CDN** — Toggle to serve assets via Revolte's global edge network for faster delivery. Configure environment variables and encrypted secrets for your web application. See [Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) for a detailed guide on managing environment-specific configurations. At the bottom of the panel, fill in the **Commit Details**: * **File Name** — The configuration file to create or update in your repository (e.g., `revolte.yml`). * **Commit Message** — A short description of what you configured (e.g., `Add web app`). * **Choose Branch** — The branch where the configuration file will be committed. Click **Commit** to save the configuration to your repository, or **Skip & deploy** to deploy immediately without committing. > **Tip:** For Single Page Applications (SPAs), set the **Error Page** to `index.html` to ensure your frontend router handles all paths correctly. # Web Service Source: https://docs.revolte.ai/guides/deployments/web-services Configure repository preferences and environment settings for a web service. This guide explains how to configure a Web service as your next service in Revolte, covering both Repo Preference and Environment Settings. Visual references are provided for each step. Choose Webservice Preset The preset chooser shows a grid of service options. The **Webservice** tile is highlighted for standard APIs or microservices. > **Note:** If your service requires a database, you can select the **Web Service + Database** preset to configure both resources simultaneously. The Repo Preference tab is identical across all service presets. See [Repository Preference](/yaml/repo-preferences/overview) for a full walkthrough of each setting. Webservice tab — QA environment The **QA** environment tab is selected. Similar to Web Apps, you can define independent resource specifications and properties for **Preview**, **QA**, **Staging**, and **Production**. This allows you to use lighter resources for development and testing while scaling up for production workloads. The center panel shows the Webservice form for the active environment: * **Service Name** — Enter a unique identifier for this service (e.g., `web_service`). * **Entry Point** — The main file that starts the service (e.g., `index.js`). * **Specifications** * **CPU & Memory** — Choose a compute tier for this service. Available options: * `1 CPU and 1 GB Memory` * `1 CPU and 2 GB Memory` * `2 CPU and 1 GB Memory` * `2 CPU and 2 GB Memory` * `2 CPU and 4 GB Memory` * `2 CPU and 8 GB Memory` * **Storage value** — Disk space in GB allocated to the service (e.g., `30`). * **Properties** * **Health EndPoint** — The URL path Revolte checks to confirm the service is running (e.g., `/health`). * **Port** — The port your service listens on (e.g., `8080`). * **Pre Script** — Commands to run before the main service starts (e.g., database migrations). * **Load Balancer Mode** — Choose between **Shared** (cost-effective) or **Dedicated** (high performance) traffic handling. * **Insights** — Select system metrics to monitor for this environment: * **Cpu** — `CPU Idle Time`, `CPU User Time`, `CPU System Time`. * **Swap** — `Swap Usage`. * **Memory** — `Total Memory Used`, `Free Memory`. * **Disk** — `Disk Used`, `Disk Total`, `Disk Free`. Configure environment variables and encrypted secrets for your service. See [Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) for a detailed guide on managing environment-specific configurations. At the bottom of the panel, fill in the **Commit Details**: * **File Name** — The configuration file to create or update in your repository (e.g., `revolte.yml`). * **Commit Message** — A short description of what you configured (e.g., `Add web service`). * **Choose Branch** — The branch where the configuration file will be committed. Click **Commit** to save the configuration to your repository, or **Skip & deploy** to deploy immediately without committing. > **Tip:** Always commit with a clear message before deploying to keep a traceable configuration history. # Guides Source: https://docs.revolte.ai/guides/index Master the deployment and operation of services across your AI-native software delivery lifecycle. Revolte guides provide step-by-step instructions and strategic patterns for managing your services, databases, and resources. Whether you are deploying a high-performance web service or orchestrating a complex background workflow, these guides help you navigate the full lifecycle of your applications. ## Deployment strategy Software delivery in Revolte is built around **Environment Intelligence**. Instead of managing disparate scripts, you define how your services behave as they move from developer intent to production reality. ### How to use these guides * **Service Operations**: Use these guides to understand the specific requirements for different runtime types (Web Apps, APIs, Cron Jobs). * **Infrastructure management**: Learn how to provision and connect relational databases, caches, and object storage buckets. * **Secure Configuration**: Implement best practices for managing secrets and environment-specific variables. ## Core deployment concepts | Concept | Purpose | When to Use | | :----------------------- | :-------------------------------------- | :--------------------------------------------------------- | | **Preview Environments** | Isolated testing of new features. | Use for every Pull Request to validate changes. | | **Service Overrides** | Environment-specific scaling and specs. | Use when production requires more CPU/Memory than staging. | | **Secrets Engine** | Encrypted runtime credentials. | Use for API keys, DB passwords, and sensitive tokens. | ## Quick start resources Launch React, Next.js, or static sites with managed edge delivery. Deploy backend services with automated health checks and scaling. Provision and connect managed PostgreSQL or MySQL instances. Configure encrypted variables and object storage across your delivery pipeline. ## Next steps Once you have your services running, explore our [Reference Section](/yaml/overview) for deep-dives into the `revolte.yaml` schema or check the [Observability](/deployments/observability/index) guide to monitor your production performance. # Cloud Architecture Source: https://docs.revolte.ai/integrations/cloud/overview Connect your cloud providers to Revolte for managed infrastructure and deployments. Revolte offers two primary ways to host your applications: using our fully managed **Revolte Cloud** or connecting your own **External Cloud Providers**. ## Revolte managed cloud The fastest way to get started. Revolte handles the underlying infrastructure, scaling, and security patching so you can focus entirely on development. Choose the managed option in your project settings to deploy instantly. Select your target region and resource tier to optimize for your users. *** ## Bring your own cloud Connect your existing cloud accounts to maintain full control over your data residency, compliance, and infrastructure costs. | Provider | Status | | :--------------------- | :----------------------- | | **AWS** | Available | | **Google Cloud (GCP)** | Coming Soon | | **Microsoft Azure** | Coming Soon | ## Next steps * [Repository Integration](/integrations/repository/overview) * [Project Management](/integrations/project-management/overview) * [Deployments Overview](/deployments/services/overview) # Connect Jira Source: https://docs.revolte.ai/integrations/project-management/jira Connect your Jira projects to Revolte for automated ticket updates. ## Configuration Revolte offers two ways to connect your Jira workspace: either during the initial onboarding flow or directly from the application workspace settings. Configure your Jira integration during your initial workspace setup sequence. Install the Revolte app from the Atlassian Marketplace and connect your Revolte workspace to your Jira site. Install and Connect Jira Map your Revolte projects to your corresponding Jira projects to finalize the integration. Map Projects Connect Jira to an active workspace at any time directly from the settings panel. From the Revolte dashboard left sidebar, click **Extensions** (or navigate to your sidebar integrations menu). Locate the **Project Management** category and click on **Jira**. Follow the same onboarding setup sequence (install from Marketplace, connect your workspace, and map your projects) as shown in the onboarding tab. Once connected, you can begin [Triggering Workflows from Jira](/integrations/project-management/jira#triggering-workflows-from-jira). ## Triggering workflows from Jira Once you install the Revolte app and map your projects, a **Revolte** section appears in the right sidebar of every linked Jira issue details page. ### Select application to trigger Revolte Jira Sidebar panel To trigger a development workflow for a specific application: 1. Open any linked Jira ticket. 2. Locate the **Revolte** panel in the right sidebar. 3. Under **Select Application**, choose the target application service from the dropdown menu. 4. Once selected, the AI agent is instantly triggered to begin analyzing requirements, executing sandbox builds, and implementing code changes. ### Sidebar panel elements The sidebar panel provides full visibility and control over the execution state: * **Issue Key**: Displays the current Jira issue key (e.g., `DND-1`). * **Revolte Project**: Displays the mapped project context (e.g., `Dotnet demo`). * **Select Application**: A dropdown to associate the issue with a specific service and launch the development workflow. * **View Workflow Details**: Action button linking directly to the Revolte dashboard. Click to view live agent execution progress, step logs, and implementation plans. * **Workflow Status**: Displays real-time state feedback (e.g., `Workflow Triggered` with a green checkmark) once the AI agent starts executing. *** ## Quick links * [AI Workflows](/ai-workflows/overview) * [Deployments Overview](/deployments/services/overview) * [Repository Integration](/integrations/repository/github) # Project Management Integrations Source: https://docs.revolte.ai/integrations/project-management/overview Sync your development progress with project management tools. Revolte integrates with project management tools to link code changes, deployments, and incidents to your tickets and issues. ## Supported tools * [Jira](/integrations/project-management/jira) * Linear Coming Soon * Azure DevOps Coming Soon # Connect GitHub Source: https://docs.revolte.ai/integrations/repository/github Connect your GitHub repositories to Revolte. ## Setup Revolte offers two ways to connect your GitHub repositories. Choose the method that best fits your workflow. Follow these steps to connect your GitHub account directly. Click on the GitHub integration button to begin the connection process. Authorize Revolte to access your repositories and manage automated workflows. For advanced security or specific access requirements, you can manually provide a GitHub Personal Access Token (PAT). 1. Generate a PAT in your GitHub Developer Settings. 2. Ensure the token has `repo` and `workflow` scopes. 3. Paste the token into the Revolte configuration field. ## Supported sources * [GitHub](/integrations/repository/github) * GitLab Coming Soon * Bitbucket Coming Soon ## Next steps * [Cloud Providers](/integrations/cloud/overview) * [Project Management (Jira)](/integrations/project-management/jira) * [Deployments Overview](/deployments/services/overview) # Migrate Existing Repositories Source: https://docs.revolte.ai/integrations/repository/migration Seamlessly migrate an existing Revolte application to a new repository source without impacting active deployments, configurations, environments, or historical operational data. ## Migration Workflow Execute a secure migration in six steps: Select your **Profile** icon and click your active organization in the Revolte Console. Navigate to the **General Settings** tab to locate the **Repository Migration** module. Click the **Migrate** button to initialize the source-linking wizard. Provide your version control provider's Personal Access Token (PAT) with appropriate repository and pipeline scopes. Verify the active project and application context, and choose your destination repository from the dynamic dropdown menu. Click **Confirm migration**. Future codebase triggers, deployments, and preview environments will track and build commits from the new repository source immediately. *** ## Reference ### FAQ No. Active deployments are completely unaffected. Running services continue to serve traffic, and subsequent builds automatically compile from the new repository source. All application history remains completely intact. Deployment tracking, security logs, and historical DORA insights persist within the active Revolte application dashboard. ### Support Policy Need assistance migrating business-critical services? Connect directly with the operations team on our [Contact Page](https://revolte.ai/contact) or reach out to your technical account manager. # Configure Monorepos Source: https://docs.revolte.ai/integrations/repository/monorepo Configure and onboard a monorepo application inside Revolte. Deploy and manage multiple applications from a single repository using Revolte’s Monorepo onboarding workflow. *** ## Configuration Workflow Follow these steps during the application onboarding phase to register a monorepo service. Navigate to the **Create Application** step of the onboarding flow. Provide a name for the application and choose your connected Git repository. Select the **Select if its a mono repo** checkbox to reveal the subdirectory configuration fields.
Create application with monorepo enabled
Configure the directory mapping using the revealed fields: * **Branch Name**: Select the Git branch containing the codebase to use for discovery and build workflows. * **Application Path**: Select the subdirectory folder containing the application's package files and configuration. Click **Create Application** to complete onboarding and initialize the service under your project context. *** ## Quick links * [Get Started](/quick-start) — Return to the core onboarding guide. * [GitHub Integration](/integrations/repository/github) — Connect your GitHub repositories. * [App & Branch Settings](/yaml/repo-preferences/app-branch-settings) — Map environments to specific branches. # Repository Integration Model Source: https://docs.revolte.ai/integrations/repository/overview Connect your code repositories to enable autonomous development and observability. Revolte integrates directly with your version control providers to monitor commits, trigger deployments, and analyze your codebase health in real-time. ## Capabilities Connecting your repository enables the core Revolte autonomous engine to: * **Automate Deployments**: Trigger builds and deployments on every push or merged pull request. * **AI-Driven Analysis**: Gain insights into commit history, code quality, and security risks. * **Preview Environments**: Automatically spin up isolated environments for every pull request to accelerate reviews. * **Zero-Downtime Migration**: Seamlessly transfer applications between repository sources or accounts without service interruption. *** ## Supported providers & operations Revolte offers deep integration with industry-standard Git providers and lifecycle management tools. Connect your GitHub repositories for automated deployments, PR insights, and risk scoring. Transfer active applications to new repository sources or accounts with zero service interruption. ### Roadmap We are continuously adding support for more version control systems. | Provider | Status | | :------------ | :----------------------- | | **GitLab** | Coming Soon | | **Bitbucket** | Coming Soon | ## Next steps * [Cloud Integration](/integrations/cloud/overview) * [Project Management](/integrations/project-management/overview) * [Deployments Overview](/deployments/services/overview) # What is Revolte Source: https://docs.revolte.ai/overview Revolte.ai— Autonomous AI SDLC for Agentic Software Delivery Revolte is an AI-native software delivery platform that helps engineering teams move from intent to production through one connected execution system. It brings planning, code generation, validation, pull request review, deployment, and observability into a governed workflow where AI executes the work and teams remain in control. *** ## Why Revolte? Traditional delivery is fragmented. Requirements, code, and deployments live in isolated silos, causing context loss and manual bottlenecks. **Revolte closes these gaps.** It connects your entire delivery lifecycle—from the first ticket to the final health check—into a single, context-aware workflow. *** ## Unified Delivery Architecture Revolte understands your repositories, environments, and deployment systems as part of a single workflow. Execution goes beyond code generation to include automated validation, deployment, and runtime verification. Your organizational standards and security policies are built directly into the workflow, ensuring every PR is safe to ship. Signals from production feed back into future workflows, helping Revolte make deployment-aware decisions over time. *** ## Core Platform Capabilities * **Execute from Intent** — Turn planning tickets into production-ready PRs with full repository context. * **Automate Governance** — Enforce security, architectural, and quality standards before human review. * **Orchestrate Deployments** — Manage ephemeral environments and production rollouts with automated health checks. * **Close the Feedback Loop** — Integrate runtime signals directly into the development cycle for faster recovery and refinement. * **Scale Team Standards** — Use reusable templates to ensure consistent delivery across microservices and platform tools. *** ## Beyond Coding: The Autonomous SDLC While standalone AI assistants (like Cursor or Codium) excel at helping individual developers write code or summarize files, Revolte is built to orchestrate the entire software delivery process. * **End-to-End Orchestration** — Move beyond file-level edits. Revolte manages the transition from a planning ticket to a verified, deployed service. * **Contextual Intelligence** — Execution is informed by your entire ecosystem—including infrastructure state, deployment histories, and security policies—not just active code. * **Autonomous Verification** — The platform doesn't just generate drafts; it executes automated validation loops to ensure every PR meets production standards. * **Production-Aware Development** — Runtime signals feed directly back into the development workflow, enabling autonomous incident resolution and performance tuning. *** ## The Connected Delivery Lifecycle Revolte acts as an operating layer across every stage of development: * **Planning** — Turn high-level intent into scoped, executable tasks with full repository context. * **Development** — Delegate implementation, refactoring, and boilerplate to parallel workflows while you focus on architecture. * **Validation** — Submit PRs that are already verified against your security and testing policies. * **Release** — Coordinate rollouts with integrated health checks and automated recovery controls. * **Operations** — Resolve production issues using the same governed systems you use for new features. *** ## Recommended Practices * **Write Clear Requirements** — Execution quality depends on clarity. Provide explicit acceptance criteria for the best results. * **Index Your Repositories** — Connect your codebase so Revolte has the full context of your architecture and dependencies. * **Define Your Guardrails** — Use policy configurations to automate your team's standards and security requirements. * **Delegate Repetitive Work** — Let Revolte handle migrations, test generation, and boilerplate so you can reclaim deep-work time. * **Review with Confidence** — Treat Revolte's output as an operationally verified draft ready for final expert review. *** ## Platform Comparison
Capability Traditional SDLC Revolte Standalone AI
*** ## Platform Systems * **[AI Workflows](/ai-workflows/overview)** — Autonomous implementation, automated validation, and governed execution. * **[YAML Configuration](/yaml/overview)** — Define your execution systems and delivery policies through the `revolte.yaml` specification. * **[Deployments](/deployments/overview)** — Coordinate services, infrastructure, and operational runtime workflows. * **[Integrations](/integrations/cloud/overview)** — Connect your planning tools, repositories, and cloud providers into a unified layer. *** ## Next Steps Ship your first autonomous workflow in minutes. Explore AI Workflows Orchestrate delivery using `revolte.yaml`. # Pricing & Usage Plans Source: https://docs.revolte.ai/pricing Understand Revolte's tiers, usage limits, and product capabilities. ## AI Model Pricing Use the table below as the technical reference layer for how different model families map to credit consumption. | Model | Family | Base input | Output | Cache write | Cache read | | ---------- | ------ | ---------: | ---------: | -----------: | ----------: | | Claude 4.5 | Haiku | 1 credit | 5 credits | 1.25 credits | 0.10 credit | | Claude 4.6 | Sonnet | 3 credits | 15 credits | 3.75 credits | 0.30 credit | | Claude 4.5 | Sonnet | 3 credits | 15 credits | 3.75 credits | 0.30 credit | | Claude 4.7 | Opus | 5 credits | 25 credits | 6.25 credits | 0.50 credit | | Claude 4.6 | Opus | 5 credits | 25 credits | 6.25 credits | 0.50 credit | | Claude 4.5 | Opus | 5 credits | 25 credits | 6.25 credits | 0.50 credit | These model-family rates are useful when technical teams want to reason more precisely about cost shape across lightweight generation, balanced day-to-day execution, and premium reasoning workflows. ## Infrastructure Billing AI is not the same as hosting. Revolte also exposes managed infrastructure and delivery operations, and these can contribute separately to total cost. Public cloud pricing shown on pricing material is an estimate using the highest-cost region, and actual cloud costs vary by configured deployment region. ### Web App Frontend hosting with global edge delivery, including custom domain management and automatic SSL/TLS. * Data transfer billed * Core hosting shown as free of cost ### Web Service Serverless deployment for APIs, microservices, and compute workloads. * ALB: \$0.042 / hr * Storage: \$0.08 / GB-month * Registry: \$0.10 / GB-month ### Database Managed data services with scalable storage and backup pricing. * Storage: \$0.115 / GB-month * Backup: \$0.095 / GB-month ### Secrets and Storage Secrets, object storage, cache, metrics, network, and supporting platform primitives. * Secrets: \$0.40 / secret-month * Object storage: \$0.023 / GB-month | Category | Metric | Approx cost | What it means | | -------------- | -------------------------- | -------------------------- | ------------------------------------------------- | | Logs | Ingestion | \$0.50 / GB | New logs written into the platform | | Logs | Storage | \$0.03 / GB-month | Retaining log data over time | | Logs | Insights queries | \$0.005 / GB scanned | Interactive analysis over retained logs | | Pipeline | Linux medium build minutes | \$0.01 / min | Build and pipeline execution time | | Metrics | Custom metrics | \$0.30 / metric-month | Custom observability signals retained monthly | | Metrics | Alarms | \$0.10 / alarm-month | Configured operational alert objects | | Object storage | Standard storage | \$0.023 / GB-month | Stored files and assets | | Object storage | GET requests | \$0.0004 / 1K requests | Read access to stored objects | | Object storage | PUT / COPY / POST / LIST | \$0.005 / 1K requests | Write and listing activity | | Network | Internet egress | \$0.09 / GB first 10TB | Outbound traffic served to users or systems | | Network | DNS | \$0.50 / hosted zone-month | Managed DNS zone cost | | Secret store | Storage | \$0.40 / secret-month | Stored secrets under management | | Secret store | API calls | \$0.05 / 10K requests | Programmatic secret retrieval or management calls | | Cache | Storage | \$0.085 / GB-month | In-memory cache capacity | A team can have low AI usage but meaningful infrastructure spend, or high AI usage with relatively low cloud runtime. These are independent levers and should be reviewed separately. ## Cost Estimation The safest way to estimate Revolte cost is to break it into layers rather than chase one all-in number. Start with the plan, then calculate likely overages, then add infrastructure only for the services you actually run. ### Step 1 — Pick the right plan Choose based on service count, environments, CI/CD run volume, and whether you need BYOC or enterprise controls. ### Step 2 — Estimate delivery overages Measure likely token usage, CI/CD runs above plan limits, and log growth above the included monthly quota. ### Step 3 — Add runtime infrastructure Include only the services you deploy: web services, databases, object storage, cache, secrets, metrics, and network egress. **Total monthly estimate ≈ base plan + AI overage + CI/CD overage + log overage + cloud runtime services** | Team pattern | Best starting plan | Primary cost drivers | What to watch first | | ---------------------------------------- | ------------------ | -------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | | Solo builder validating the platform | Free | AI prompts, a few CI runs, light logs | Whether experimentation stays inside 5 credits, 500 runs, and 5 GB logs | | Small startup with a few active services | Pro | CI/CD volume, preview environments, web services, logs | Run frequency, preview sprawl, and whether AI-heavy workflows are repeated too broadly | | Growing multi-service team | Pro or Enterprise | Service count, logs, object storage, database growth, support expectations | When service count, compliance, or control needs exceed standard Pro boundaries | | Regulated or platform-scale organization | Enterprise | Custom caps, SLA, BYOC, compliance modules, large runtime footprint | Private cloud, on-prem, audit support, SSO/RBAC, and modular product packaging | ### Example overage math If a team exceeds its included log quota by 20 GB in a month, the listed PAYG log ingestion rate implies: `20 GB × $0.50 = $10.00` This is separate from any retained log storage or log query scanning cost. ### Another simple calculation If a team exceeds its CI allowance by 1,000 runs, the listed PAYG CI run rate implies: `1,000 runs × $0.01 = $10.00` This should be monitored alongside build-minute-based pipeline cost and infrastructure usage. # Quick Start Source: https://docs.revolte.ai/quick-start Connect an application, configure its delivery context, and submit a focused Build request that produces a reviewable pull request. Revolte provides multiple AI-assisted development and deployment workflows to help teams move from code to production. * **Local Development**: Build locally using the Revolte CLI and AI-assisted development workflows. * **AI Delivery Workflows**: Transform Jira requirements into structured engineering execution and pull request workflows. * **Managed Deployments**: Deploy existing applications through managed infrastructure and automated delivery orchestration. Each pathway supports different stages of the software delivery lifecycle while operating through a connected execution and deployment model. Follow the guides below to set up your first Revolte workflow and get started with your initial development session. *** ## Onboarding Walkthrough Follow these interactive steps to connect your repository and launch your first application: [Create your Revolte account](https://console.revolte.ai/auth/login) and open the onboarding flow. Add your organization details and role so Revolte can tailor the workspace context.
Workspace details modal
Choose where Revolte should run and manage the application infrastructure. See [Cloud Integrations](/integrations/cloud/overview) for details.
Cloud target selection
Connect the Git provider that contains the repository Revolte should use for generated work. See [Repository Integrations](/integrations/repository/overview) for details.
Source control integration
Optionally connect a product management tool so issues or requirements can be linked to build workflows. See [Project Management Integrations](/integrations/project-management/overview) for details.
Project management integration
Create or select the project that groups related applications under the same product context.
Project creation form
Name the application and select the repository Revolte should manage. * **Select if its a mono repo**: Select this checkbox if the target repository contains multiple independent applications or microservices rather than a single codebase. Learn more in the [Monorepo Configuration Guide](/integrations/repository/monorepo).
Application creation form
Use the workflow guide below to identify the best development and deployment path for your application.
Choose a pathway
With your application ready, **Select a workflow pathway** to continue development, automate engineering workflows, or manage deployments.
Choose a pathway
### **Select a workflow pathway** Create a new application feature locally in under 5 minutes. Build and manage structured development workflows in an easy, automated way. Deploy applications with automated infrastructure and lifecycle management. # Build APIs from a Spec Source: https://docs.revolte.ai/use-cases/api-from-spec Hand Revolte an OpenAPI spec and have it implement the endpoints against your existing backend patterns — routes, validation, and tests included. This walkthrough points Revolte at a real OpenAPI spec and shows what comes back: routes wired into your existing structure, validation that mirrors the spec, and a test suite that already passes. ***
Kick off the session by asking Revolte to map the codebase's conventions before it writes anything. Read the summary it comes back with — it's what decides where the new endpoint should live. ```text theme={"dark"} Explore the codebase and explain how APIs are currently implemented. Focus on: - Existing routing and API structure. - Authentication and authorization flow. - Service and database layer patterns. - Validation and error handling approach. - Existing tests and testing conventions. Summarize your findings and suggest where this new API should live. ``` With the conventions settled, point Revolte to the OpenAPI spec and name the endpoints you want built. It reads the file directly for paths, request and response schemas, and expected behavior — you shouldn't need to restate any of that in the prompt. ```text theme={"dark"} Implement the two endpoints defined in spec/openapi.yaml: - POST /api/v1/invoices - GET /api/v1/invoices/{id} Requirements: - Follow the existing project architecture and conventions. - Reuse existing services, utilities, and middleware where possible. - Validation and status codes should match the spec exactly. - Follow the existing authentication and authorization pattern. Tests: - Write tests covering both endpoints, including the error cases. - Run the full suite and fix any failures before finishing. ``` Revolte works through the implementation and makes the changes. If you're in the chat view, click **View changes** to open the diff on the right and follow along: ```typescript theme={"dark"} // routes/invoices.ts router.post( "/api/v1/invoices", requireAuth, validateBody(createInvoiceSchema), invoicesController.create ); router.get( "/api/v1/invoices/:id", requireAuth, invoicesController.getById ); ``` ```typescript theme={"dark"} // schemas/invoice.schema.ts export const createInvoiceSchema = z.object({ customerId: z.string().uuid(), lineItems: z.array( z.object({ description: z.string(), quantity: z.number().int().min(1), unitPriceCents: z.number().int().min(0), }) ).min(1), dueDate: z.string().date().optional(), }); ``` Before you dig into the diff itself, check the test output further up in the session — Revolte runs the suite it just wrote as part of the same run, so a failure shows up here first instead of surprising you in review. ```text theme={"dark"} PASS test/invoices.test.ts POST /api/v1/invoices ✓ creates an invoice for a valid payload (38ms) ✓ rejects a payload missing lineItems (11ms) ✓ returns 422 when the customer has no payment method (9ms) GET /api/v1/invoices/:id ✓ returns the invoice when it exists (7ms) ✓ returns 404 for an unknown id (6ms) Tests: 5 passed, 5 total ``` Once the diff and tests both check out, stay in the same session rather than opening a new one — it already has the spec and the codebase's conventions loaded, so a follow-up prompt like either of these stays scoped instead of starting over: ```text theme={"dark"} Add pagination and filtering to GET /api/v1/invoices. Requirements: - Support page and limit query params. - Allow filtering by status (draft, sent, paid, overdue). - Follow the existing response format. ``` ```text theme={"dark"} Add a PATCH /api/v1/invoices/:id endpoint to update line items on a draft invoice, with tests covering the case where the invoice has already been sent. ```
*** ## Related * [Fix a Production Bug](/use-cases/fix-a-bug) * [Generate Tests](/use-cases/generate-tests) * [YAML Configurations](/yaml/overview) # Turn a Figma Design into Working Code Source: https://docs.revolte.ai/use-cases/figma-to-code Connect Figma to Revolte and turn a design frame into UI code that matches your project's components and conventions. Design handoff usually means a designer drops a link in Slack and an engineer spends the next hour translating spacing, tokens, and component names by hand. This walkthrough connects Revolte directly to a Figma frame so it can read the design and implement it against your actual codebase. ***
In Figma, go to **Settings → Security → Personal Access Tokens → Generate new token** and enable: * `current_user:read` * `file_content:read` * `library_asset:read` * `library_content:read` * `file_dev_resource:read` Then in Revolte, go to **Extensions → Figma**, paste the token, and submit.
Figma connected in Revolte's Extensions panel
Any file you have access to in Figma is now available to reference in future sessions. Open a revolte session in the repo and point at a specific frame rather than an entire file, and describe the implementation constraints up front. ```text theme={"dark"} Implement the pricing page from this Figma frame: https://figma.com/file/abc123/Pricing-Page Requirements: - Reuse existing UI components wherever possible. - Follow our design system, Tailwind config, and project conventions. - Match layout, spacing, typography, and styling shown in the design. - Ensure the page is fully responsive across desktop, tablet, and mobile. - Only create new components when a suitable one doesn't already exist. - Wire the page into the appropriate route. Verification: - Run the app locally and check the implementation. - Capture screenshots at desktop, tablet, and mobile widths. - Compare against the Figma design and fix any visual differences. ``` Revolte reads the Figma frame, maps the design to your codebase, implements the components, then opens the app in a browser to check the result visually. * **Reads the frame** — Pulls the component tree, design tokens (colors, spacing, radii), typography, and auto-layout properties straight from the specified frame. * **Maps tokens to your system** — Matches Figma colors and spacing to the closest values in your existing design system instead of hardcoding raw pixel values. * **Builds the components** — Implements the UI following your project's existing patterns, reusing shared components wherever the design already matches. * **Checks it in the browser** — Starts the app locally, navigates to the new page, and compares it against the Figma frame at multiple viewports. Since the session already has context on both the repo and the frame, you can refine with short follow-ups instead of re-explaining the task: * "Use the existing `Button` component for all primary actions." * "Implement the hover and active states from the design." * "Add loading and error states to this page." * "Match the mobile layout shown in the frame — it collapses to a single column."
*** ## Tips * Link individual frames instead of whole Figma files — it keeps the context focused. * Call out components you expect to be reused if your design system has established patterns. * Include interaction and accessibility requirements in the initial prompt; they're easy to miss otherwise. ## Related * [Quick Start](/quick-start) * [Build APIs from a Spec](/use-cases/api-from-spec) # Investigate and Fix a Production Bug Source: https://docs.revolte.ai/use-cases/fix-a-bug Go from an error report to a root cause, a scoped fix, and regression coverage. Bug reports rarely arrive with a root cause attached — usually it's an error message, a screenshot, or a one-line description from support. This walkthrough uses whatever context you have to trace the failure back to its source and land a fix without widening scope. ***
Open a session and pass along anything available: logs, stack traces, user reports, repro steps, or recent changes to the affected area. Don't wait until you have a full picture — a partial one is enough to start. ```text theme={"dark"} We're seeing failures when users export large reports. - Some users get a 500 error during export. - Small reports work fine. - Only happens on accounts with large datasets. Error: "Memory limit exceeded while generating report" Investigate the cause and propose a fix. ``` Before it touches any code, Revolte traces the failure through the app: locating the relevant code paths, following how data moves through the system, and checking logs and related services. Read the root cause and proposed approach it reports back with, and correct it here if something's off — the fix in the next step builds directly on this. ```text theme={"dark"} Root cause: The report generation service loads all records into memory before processing. Large accounts exceed the configured limit. Suggested fix: Process records in batches instead of loading the full dataset. ``` If the root cause checks out, tell Revolte to go ahead — and be explicit about how you want the fix verified, not just written. ```text theme={"dark"} Implement the recommended fix. Requirements: - Preserve existing report generation behavior. - Optimize memory usage for large datasets. - Follow existing service patterns. Verification: - Run relevant tests. - Reproduce the original failure to confirm it's resolved. - Check for unintended side effects. - Add regression coverage where it's missing. ``` Revolte works through the fix and closes the loop itself — running relevant tests, reproducing the original failure to confirm it's resolved, checking for side effects, and adding regression coverage where it's missing. If you're in the chat view, click **View changes** to open the diff on the right and follow along. Once the fix is verified, stay in the same session rather than starting a new one — it already has the full context to look wider: ```text theme={"dark"} Check whether other report generation flows have the same memory issue. ``` ```text theme={"dark"} Add monitoring around this workflow so we catch similar issues earlier next time. ```
*** ## Related * [Trace a Workflow](/use-cases/trace-a-workflow) * [Generate Tests](/use-cases/generate-tests) * [Application Logs](/deployments/observability/application-logs) # Generate Tests for Existing Code Source: https://docs.revolte.ai/use-cases/generate-tests Find coverage gaps in an existing feature and generate tests that follow your project's conventions. Writing tests for code you didn't just write means first figuring out what's already covered and what isn't. This walkthrough has Revolte map an existing feature's coverage, propose a test plan, and only then implement tests — so the result targets real gaps instead of duplicating existing coverage. ***
Before writing anything, ask Revolte to map what the feature does and how much of it is already tested — useful when you didn't write the code yourself. Read through the summary it returns; the plan in the next step is only as good as the gaps identified here. ```text theme={"dark"} Analyze the checkout flow and summarize the current test coverage. Focus on: - How orders are created and processed. - The payment validation flow. - Existing unit and integration tests. - Scenarios that aren't covered today. Don't make changes yet — just summarize the flow, the gaps, and what you'd recommend testing. ``` With the gaps identified, have Revolte turn them into a concrete, prioritized plan before any tests get written. Skim the plan and reorder or drop anything that doesn't match what you'd actually prioritize — it's the checklist the next step implements against. ```text theme={"dark"} Based on that analysis, put together a test plan to improve checkout flow coverage. Include: - Missing critical scenarios. - Successful checkout paths. - Payment failure cases. - Invalid input handling. - Edge cases around order creation. Prioritize by which tests give the most confidence. ``` If a priority looks off or a scenario's missing, say so before anything gets implemented — it's a lot cheaper to fix here than after the tests are written. Skip this if the plan already looks right. ```text theme={"dark"} Move invalid input handling above payment failure cases, and add a scenario for partial refunds. ``` Once the plan looks right, approving it is enough — Revolte already has the plan from the session, so there's no need to restate it. ```text theme={"dark"} Looks good, implement it. Follow the existing testing patterns in the repo, run the suite, and fix any failures. ``` While that runs, here's what to expect in the session before you're asked to review anything — Revolte works through it in stages: * **Analyzes the feature** — what it does and what it depends on. * **Reviews existing coverage** — what's tested today and where the real gaps are. * **Plans scenarios** — critical paths, edge cases, and failure modes worth covering. * **Writes the tests** — matching your project's existing structure and conventions. * **Verifies** — runs the suite, fixes failures, and confirms coverage actually improved. If you're in the chat view, click **View changes** to open the diff on the right and follow along. Once the suite lands and you've checked coverage actually improved, stay in the same session and go after the scenarios that matter most for reliability: ```text theme={"dark"} Add regression tests for failed payment and order rollback scenarios. ``` Or point Revolte at the suite itself rather than new coverage: ```text theme={"dark"} Review the current checkout tests and flag anything that's flaky or hard to maintain. ```
*** ## Related * [Investigate and Fix a Production Bug](/use-cases/fix-a-bug) * [Build APIs from a Spec](/use-cases/api-from-spec) # Use Cases Gallery Source: https://docs.revolte.ai/use-cases/overview Walkthroughs showing how teams use Revolte for real engineering work, from UI implementation to production debugging. Turn a Figma frame into working UI that matches your existing components and conventions. Implement backend endpoints from an API specification, fit to your codebase's existing patterns. Go from an error message or user report to a root cause, a fix, and regression coverage. Find coverage gaps in an existing feature and generate tests that follow your project's conventions. Follow an execution path across services and queues to find where it breaks, then fix it. # Trace a Workflow to Find and Fix Bugs Source: https://docs.revolte.ai/use-cases/trace-a-workflow Follow an execution path across services and queues to find where it actually breaks, then land a scoped fix once the cause is confirmed. **Scenario:** A user reports they never got notified when their build finished. You didn't write the notification pipeline, and it spans an event emitter, a queue, a consumer, and two delivery channels. Grepping for "notification" turns up a dozen files — before you can fix anything, you need to know which of them are actually on this path, and in what order. ***
Open a session in the repo and describe the trigger the same way you'd describe it to a teammate — no file names required. ```text theme={"dark"} Trace how a notification reaches a user, starting from the event that triggers it (a build completing) through to delivery. List every file and function on the path, in order. ``` ```text theme={"dark"} 1. jobs/buildRunner.ts → emits `build.completed` 2. events/emitter.ts → publishes to the `notifications` queue 3. workers/notificationConsumer.ts → handleBuildCompleted() builds the payload 4. delivery/dispatch.ts → dispatch() fans out to websocket + push 5. client/NotificationCenter.tsx → renders on `notification:new` ``` Five hops, in actual call order. Skim it against what you already know before moving on — the next part builds on this map, so it's worth correcting now if a hop looks off. Stay in the same session so you don't have to re-establish context. Pick the hop that looks riskiest — usually wherever two things happen back to back without visible error handling — and narrow in on it one question at a time. ```text theme={"dark"} Does dispatch() retry either channel if the send fails? ``` > No. Both `websocketChannel.send()` and `pushChannel.send()` are single-attempt, best-effort calls — no retry on either one. No retries isn't the whole story on its own — a flaky send on one channel shouldn't matter if the other still fires. ```text theme={"dark"} If there's no retry, is there at least a fallback — does push still fire if the websocket send fails? ``` > Unclear from a static read. Both sends live inside the same `try/catch`, so whether `pushChannel.send()` runs after a websocket failure depends on exactly where execution goes when the throw happens. ```text theme={"dark"} Walk through what happens step by step when websocketChannel.send() throws inside that try/catch — does execution ever reach the pushChannel.send() line? ``` > No — the throw jumps straight to the catch block, which only logs at debug level. `pushChannel.send()` is never reached. One flaky channel silently kills the other. That's the kind of failure a text search doesn't surface — it takes following the event through the queue and reading how the error is actually handled. The failure mode is confirmed, so ask for the fix directly. ```text theme={"dark"} Fix dispatch() so a failure in one channel can't block the other, and add a regression test. ``` > * Each channel send gets its own `try/catch`. > * Failures log at `warn` with the channel name and notification id. > * New test: push still fires when the websocket send throws. Review the diff and run the new test locally before opening a PR, same as with any change — tracing the flow gets you to that point faster, it doesn't replace it.
*** ## Why this matters Async boundaries — queues, consumers, fan-out — are exactly where a human loses the thread scanning files by hand. Tracing the actual execution path, including how errors are swallowed, turns "user says they didn't get notified" into a specific line of code and a fix, in one pass. ## Related * [Investigate and Fix a Production Bug](/use-cases/fix-a-bug) * [Application Logs](/deployments/observability/application-logs) # Environment Configuration Source: https://docs.revolte.ai/yaml/environment-settings/overview Manage service-specific configurations across different environments.
**Environment Settings** allow you to define and manage unique configurations for your services across all your Revolte environments, including **Production**, **UAT**, **QA**, and **Preview** environments. ## How to navigate To manage these settings from the project dashboard: 1. Select your project from the Revolte dashboard. 2. Navigate to **YAML Configuration** > **Environment Settings**. 3. Use the environment tabs to switch between settings for Production, UAT, QA, or Preview environments. ## Environment-specific configuration In your `revolte.yaml`, you can specify different values for variables, resource limits, and automated workflows depending on the target environment. ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Sideline HQ appName: sideline-web-admin env: production: branch: main staging: branch: staging qa: branch: qa preview: # Settings applied to ephemeral preview environments branch: "*" ``` ## Key configuration areas * **[Pre-build Workflow](/yaml/environment-settings/pre-build)**: Configure environment-specific pre-build automation, quality gates, and automated reviews. * **[Services & Resources](/yaml/environment-settings/services)**: Define resource specifications (CPU, Memory) and scaling policies per environment. * **[Variables & Secrets](/yaml/environment-settings/resource-specifications/variables)**: Manage environment variables and secure secrets for different deployment targets. # Environment Pre-build Flow Source: https://docs.revolte.ai/yaml/environment-settings/pre-build Configure environment-specific pre‑build automation and quality gates.
The **Pre‑build Workflow** allows you to define checks and automation that run before your service is built and deployed to a specific environment. ## Configuration In your `revolte.yaml`, you can enable or disable pre‑build features per environment: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Sideline HQ appName: sideline-web-admin env: production: branch: main codeReview: true codeQuality: true testSuite: true automationTestSuite: true ``` ## Key modules * **Code Review**: Activates AI‑driven PR summarization and fix suggestions. * **Code Quality**: Enforces linting and style rules. * **Test Suite**: Executes your unit and integration tests. * **Automation Test Suite**: Runs end‑to‑end automation tests. ## Related * [Agent Workflow](/yaml/repo-preferences/agent-workflow) * [Pipeline Overview](/yaml/repo-preferences/pipeline/overview) ## Next steps * [Configure Deployment Workflow](/yaml/environment-settings/services) * [Manage Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) * [Learn about Syncing Changes](/yaml/syncing) # Cache Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/cache Cache services (like Redis) require prioritized memory to ensure low-latency data retrieval. ## Memory allocation | Parameter | Recommended | Description | | ------------------- | ------------- | -------------------------------------- | | **Memory** | `1 GB` | Dedicated RAM for the caching layer. | | **Eviction Policy** | `allkeys-lru` | How the cache handles memory pressure. | ## Configuration ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main services: rid_4: type: CACHE name: cache specifications: cpu: 2 memory: 0.5 ``` ## Related * [Web Service](/yaml/environment-settings/resource-specifications/web-service) * [Database](/yaml/environment-settings/resource-specifications/database) ## Next steps * [Manage Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) * [Set up Storage Buckets](/yaml/environment-settings/resource-specifications/storage-bucket) * [Sync your Changes](/yaml/syncing) # Database Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/database Define storage and instance sizing for your data layer. Databases require persistent storage and prioritized memory for query performance. ## Storage configuration | Parameter | Type | Description | | ----------- | ------- | ------------------------------------------------------ | | **Storage** | `30 GB` | Persistent disk space for your database. | | **IOPS** | `3000` | Provisioned throughput for high-performance databases. | ## Instance sizing Choose an instance size that matches your dataset and concurrency needs. ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main services: rid_2: type: DATABASE name: db specifications: cpu: 2 memory: 1 storage: 30 engine: postgres ``` ## Database Connection Injection Provisioning a database service (e.g., named `db` under your YML services configuration) automatically injects the corresponding connection credentials into the environment variables of all other services within the same environment. This requires no manual secret configuration. The following environment variables are automatically injected at runtime: ```yaml theme={"dark"} DATABASE_HOST: '#{db.dbUrl}' DATABASE_PORT: '#{db.dbPort}' DATABASE_USERNAME: '#{db.dbUsername}' DATABASE_PASSWORD: '#{db.dbPassword}' DATABASE_NAME: '#{db.dbName}' ``` *(Note: If your database service name is different from `db`, replace `db` with your exact service name in the references above.)* ## Related * [Web Service](/yaml/environment-settings/resource-specifications/web-service) * [Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) ## Next steps * [Configure Caching](/yaml/environment-settings/resource-specifications/cache) * [Set up Storage Buckets](/yaml/environment-settings/resource-specifications/storage-bucket) * [Sync your Changes](/yaml/syncing) # Storage Bucket Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/storage-bucket Configure object storage for assets, backups, and user uploads. Storage Buckets provide scalable object storage for your application. ## Configuration parameters | Parameter | Example | Description | | -------------------- | ------------- | --------------------------------------------------------------------- | | **bucketName** | `test-bucket` | The unique name of the storage bucket. | | **versioningStatus** | `suspended` | Enables or suspends object versioning (e.g., `enabled`, `suspended`). | | **public** | `false` | Defines if the bucket data is publicly accessible. | | **storage** | `100` | Total storage allocation in GB. | ## Access policy Define who can access the bucket data. ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main services: rid_1: type: STORAGE_BUCKET name: assets-bucket specifications: storage: 100 configurations: bucketName: test-bucket versioningStatus: suspended public: false ``` ## Related * [Web Service](/yaml/environment-settings/resource-specifications/web-service) * [Database](/yaml/environment-settings/resource-specifications/database) ## Next steps * [Configure Caching](/yaml/environment-settings/resource-specifications/cache) * [Manage Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) * [Sync your Changes](/yaml/syncing) # Variables & Secrets Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/variables Manage environment variables and secure secret injection. Revolte provides a unified system to manage environment-specific configurations and sensitive data through two distinct categories: **Variables** and **Secrets**. ## Secret configuration workflow Managing sensitive data follows a simple two-step process: 1. **Define in YAML**: Declare the variable in your `revolte.yaml` using the injection syntax: `VARIABLE_NAME: "#{SECRET_KEY}"`. 2. **Assign Value in Dashboard**: Go to the **Secret Engine** tab in your project dashboard and add the actual sensitive value for that `SECRET_KEY`. ### Example: configuring JWT secrets In your `revolte.yaml`, you reference the secret key you intend to use: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main services: rid_1: type: WEB_SERVICE properties: variables: JWT_SECRET: "#{JWT_SECRET}" ``` Once defined, navigate to the **Secret Engine** in the Revolte dashboard to add the actual value for `JWT_SECRET`. Revolte will then securely inject this value into your service at runtime. ## Related * [Service Definitions](/yaml/environment-settings/services) * [Web Service Configuration](/yaml/environment-settings/resource-specifications/web-service) * [Database Configuration](/yaml/environment-settings/resource-specifications/database) # Web App Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/web-app Configure static frontend applications with CDN and environment mapping. **Web Apps** represent static frontend applications (React, Vue, Next.js static, etc.) that are served via CDN. Unlike Web Services, these do not require CPU/Memory specifications but focus on CDN and routing properties. ## Configuration Define your static asset properties and frontend environment variables in `revolte.yaml`. ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" workflow: developerWorkflow: enabled: true env: production: branch: main services: rid_1: type: WEB_APP name: web-app_service entryPoint: index.js properties: indexPage: index.html errorPage: index.html enableCdn: false variables: VITE_API_HOST: "#{beBaseURL}" VITE_GOOGLE_PLACES_API_KEY: "#{googlePlacesAPIKey}" ``` ## Related * [Web Service Configuration](/yaml/environment-settings/resource-specifications/web-service) * [Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) * [YAML Overview](/yaml/overview) # Web Service Source: https://docs.revolte.ai/yaml/environment-settings/resource-specifications/web-service Configure compute resources and scaling for web-facing services. Web Services require consistent compute and memory allocation to handle incoming traffic. You can define these resources per environment to optimize for cost and performance. ## Resource allocation | Parameter | Recommended (Prod) | Recommended (Staging) | | ----------- | ------------------ | --------------------- | | **CPU** | `4` | `2` | | **Memory** | `16 GB` | `8 GB` | | **Storage** | `30 GB` | `15 GB` | ## Configuration Define your compute resources and monitoring insights in `revolte.yaml`. ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main services: rid_1: type: WEB_SERVICE name: web_service entryPoint: index.js properties: health: /health port: 8080 loadBalancerMode: dedicated variables: JWT_TOKEN_SECRET: "#{JWT_TOKEN_SECRET}" JWT_TOKEN_EXPIRY: "#{JWT_TOKEN_EXPIRY}" insights: cpu: - cpu_time_idle swap: - swap_used mem: - mem_total disk: - disk_total specifications: cpu: 4 memory: 16 storage: 30 ``` ## Related * [Overview](/yaml/environment-settings/resource-specifications/overview) * [Variables & Secrets](/yaml/environment-settings/resource-specifications/variables) ## Next steps * [Configure Databases](/yaml/environment-settings/resource-specifications/database) * [Set up Storage Buckets](/yaml/environment-settings/resource-specifications/storage-bucket) * [Sync your Changes](/yaml/syncing) # Understanding Revolte YAML Source: https://docs.revolte.ai/yaml/overview Define and manage your entire application lifecycle through a single version-controlled configuration file. Manage your entire application lifecycle, infrastructure, and deployment logic through a single version-controlled `revolte.yaml` file. Revolte YAML Overview *** ## Reference example ```yaml revolte.yaml {expandable} theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: demo application # Global Configuration & AI Workflows config: codeReview: summarize: true suggestFixes: true commentStyle: Balanced codeQuality: codeStyle: rules: javascript/arrayCallbackReturn: warn testSuite: command: npm run test automationTestSuite: command: npm run test:automation workflow: developerWorkflow: enabled: true # Environment-specific Overrides env: production: branch: main codeReview: true codeQuality: true testSuite: true automationTestSuite: true services: rid_1: type: WEB_SERVICE name: web_service entryPoint: index.js properties: health: /health port: 8080 loadBalancerMode: dedicated variables: BASE_URL: /api/v1 JWT_TOKEN_SECRET: "#{JWT_TOKEN_SECRET}" SESSION_SECRET: "#{SESSION_SECRET}" insights: cpu: - cpu_time_idle - cpu_time_user - cpu_time_system swap: - swap_used mem: - mem_total - mem_free disk: - disk_used - disk_total - disk_free specifications: cpu: 2 memory: 1 storage: 30 autoScaling: replica: min: 1 max: 1 utilization: cpu: target: 70 memory: target: 70 behavior: scaleDown: stabilizationWindow: 300 staging: branch: staging codeReview: true codeQuality: true testSuite: true automationTestSuite: true services: rid_1: type: WEB_SERVICE name: web_service entryPoint: index.js properties: health: /health port: 8080 loadBalancerMode: dedicated variables: BASE_URL: /api/v1 specifications: cpu: 2 memory: 1 storage: 30 qa: branch: qa codeReview: true codeQuality: true testSuite: true automationTestSuite: true services: rid_1: type: WEB_SERVICE name: web_service entryPoint: index.js properties: health: /health port: 8080 loadBalancerMode: shared variables: BASE_URL: /api/v1 specifications: cpu: 2 memory: 1 storage: 30 # Ephemeral Preview Environments preview: codeReview: true codeQuality: true testSuite: true automationTestSuite: true services: rid_1: type: WEB_SERVICE name: web_service entryPoint: index.js properties: health: /health port: 8080 loadBalancerMode: dedicated variables: BASE_URL: /api/v1 specifications: cpu: 2 memory: 1 storage: 30 ``` **Key Configuration Highlights:** * `loadBalancerMode: dedicated` provisions a dedicated load balancer instead of shared routing. * `developerWorkflow.enabled` activates Revolte's developer-centric automation workflow. * `autoScaling` automatically adjusts service replicas based on CPU and memory utilization thresholds. * `variables` defines environment variables injected into your runtime. Use `#{SECRET_NAME}` to reference Revolte secrets securely. * `insights` enables granular telemetry collection (CPU, Memory, Disk, Swap) for deep runtime observability and AI-driven performance analysis. *** ## How it works Place the `revolte.yaml` file in your repository root. Revolte automatically detects this file upon repository connection. **Commit to Sync:** Any subsequent changes to your `revolte.yaml` file must be committed and pushed to your repository for the Revolte engine to recognize and apply the latest configuration. Specify your service types (Web Service, Database, Cron Job) and their respective resource requirements. Assign Git branches to target environments. Pushing code to these branches triggers the corresponding deployment workflow. The Revolte AI engine parses your YAML to provision infrastructure, configure load balancers, and set up observability dashboards. *** ## Related * [Repository Preferences](/yaml/repo-preferences/overview) * [Environment Settings](/yaml/environment-settings/services) * [Deployments](/deployments/services/overview) * [Integrations](/integrations/cloud/overview) # Configure Agent Workflows Source: https://docs.revolte.ai/yaml/repo-preferences/agent-workflow Enable AI-assisted coding, debugging, and task execution. The **Agent Workflow** enables Revolte's AI agent to assist you directly within your repository context.
## How to enable Follow these steps to activate the AI Agent for your repository. Open your project dashboard and select **YAML Configuration** > **Repo Preferences**. Locate the **Developer Workflow** section and toggle the switch to **Enabled**. Enter a commit message and select your target branch to persist the changes. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Configuration In your `revolte.yaml`, you can toggle this workflow globally: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" workflow: developerWorkflow: enabled: true # Activates AI-assisted coding and debugging ``` ## Quick links * [App & Branch Settings](/yaml/repo-preferences/app-branch-settings) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) * [YAML Overview](/yaml/overview) # Configure App & Branch Settings Source: https://docs.revolte.ai/yaml/repo-preferences/app-branch-settings Configure your application framework and environment branch mapping.
## How to configure Follow these steps to define your application identity and branch strategy. Navigate to **YAML Configuration** > **Repo Preferences** from your project dashboard. Assign specific Git branches to your **Production**, **UAT**, and **QA** environments. Enter a commit message and select your target branch to persist the changes. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Branch mapping Map your Git branches to Revolte environments to enable automated deployments. | Git Branch | Revolte Environment | Behavior | | -------------- | ------------------- | ---------------------------------------------------------------------------------------- | | `main` | **Production** | Live production traffic and primary rollout target. | | `staging` | **UAT** | Pre-production validation and user acceptance testing. | | `qa` | **QA** | Automated testing and quality assurance cycles. | | \* (Any other) | **Preview** | Ephemeral environments with a default 3-day retention period Customizable . | ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" env: production: branch: main # Maps production environment to the main branch staging: branch: staging # Maps UAT environment to the staging branch qa: branch: qa # Maps QA environment to the qa branch ``` **How to Customize Preview Expiry:** By default, Preview environments automatically destroy themselves after 3 days. To adjust this lifespan: 1. Open your project dashboard and select **Settings** from the left navigation bar. 2. Navigate to **General Settings** > **Preview environment expiry**. 3. Enter your preferred duration, select the unit (**Day** or **Hour**), and click **Update**. *Note: This applies to upcoming deployments only.* ## Service integration Branch mapping triggers automated deployments for all services in the environment. ```yaml revolte.yaml theme={"dark"} revolte: env: production: branch: main services: rid_1: type: WEB_SERVICE name: api-gateway # Revolte deploys this service when code is pushed to 'main' ``` ## Quick links * [Agent Workflow](/yaml/repo-preferences/agent-workflow) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) * [YAML Overview](/yaml/overview) # Common errors Source: https://docs.revolte.ai/yaml/repo-preferences/common-errors ## Common Validation Errors When Revolte validates your `revolte.yaml`, it may show configuration errors if required environment settings are missing. These errors usually occur when branches or services have not been configured in **Repository Preferences**. *** ### Missing `branch` Property If you see an error like this: ```text theme={"dark"} Line 16 Missing property "branch" Line 19 Missing property "branch" Line 22 Missing property "branch" ``` Branch mapping configuration error it means one or more environments have not been mapped to a Git branch. How to fix 1. Navigate to Repository Preferences → Application and Branch Setting. 2. Configure branch mappings for each environment. 3. Save the configuration. 4. Commit and push the updated revolte.yaml. If your repository only uses a single branch, map the main branch to all environments. ### Missing services Property If you see errors similar to: ```text theme={"dark"} Line 16 Missing property "services" Line 20 Missing property "services" Line 24 Missing property "services" ``` Branch mapping configuration error it means an environment has been created but no service definition has been configured. How to fix 1. Navigate to Repository Preferences → Preset and Service. 2. Select the application type you want to deploy. 3. Choose the appropriate service configuration: * Web App * Web Service * Web Service + Database * Cron Job * Cron + Database * Web Service + Storage Bucket 4. Save the configuration. 5. Commit and push the updated revolte.yaml. # Code Quality Source: https://docs.revolte.ai/yaml/repo-preferences/pipelines/code-quality Configure automated linting and static analysis for your repository. **Code Quality** ensures that every commit adheres to your team's coding standards. Revolte integrates with industry-standard linters to provide immediate feedback on maintainability and potential bugs.
## How to configure Customize your code quality standards through the Revolte dashboard. Navigate to **YAML Configuration** > **Repo Preferences** and locate the **Pipelines** section. Click on the **Code Quality** component to view detailed configuration options. Use the YAML editor to specify linting rules and severity levels (error, warn, off). Save your configuration to the repository. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Configuration example Enable and customize code quality checks in your `revolte.yaml`: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" config: pipeline: codeQuality: codeStyle: rules: javascript/arrayCallbackReturn: warn javascript/constructorSuper: warn javascript/forDirection: warn javascript/getterReturn: warn javascript/noAsyncPromiseExecutor: error ``` ## Supported features * **Static Analysis**: Detects anti-patterns and potential runtime errors. * **Linting**: Enforces consistent formatting and style rules. * **Complexity Metrics**: Identifies overly complex functions that may need refactoring. ## Quick links * [Test Suite](/yaml/repo-preferences/pipelines/test-suite) * [Pipelines Overview](/yaml/repo-preferences/pipelines/overview) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) # Pipeline Orchestration Source: https://docs.revolte.ai/yaml/repo-preferences/pipelines/overview Manage deployment triggers, manual gates, and execution policies. ## Pipeline components Pipelines in Revolte are composed of several automated stages to ensure software reliability: 1. **Code Quality**: Automated static analysis and linting to maintain high standards of code maintainability and security. 2. **Test Suite**: Execution of unit and integration tests to verify functional correctness. 3. **Automation Test Suite** Coming Soon : End-to-end and browser-based testing for full-system validation. ## How to configure Manage these components directly from the project dashboard. Navigate to **YAML Configuration** > **Repo Preferences** and locate the **Pipelines** section. Enable or disable **[Code Quality](/yaml/repo-preferences/pipelines/code-quality)** and **[Test Suite](/yaml/repo-preferences/pipelines/test-suite)** execution for your repository. Save your configuration to the repository. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Quick links * [YAML Overview](/yaml/overview) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) * [Agent Workflow](/yaml/repo-preferences/agent-workflow) * [Preset & Service](/yaml/repo-preferences/preset-service) # Test Suite Source: https://docs.revolte.ai/yaml/repo-preferences/pipelines/test-suite Manage automated unit and integration testing. **Test Suite** component automates the execution of your project's tests. By integrating testing into your pipeline, you can ensure that new changes do not introduce regressions.
## How to configure Manage your testing automation through the project dashboard. Navigate to **YAML Configuration** > **Repo Preferences** and locate the **Pipelines** section. Click on the **Test Suite** component to configure execution triggers. Toggle automated runs for specific branches or promotion events. Save your configuration to the repository. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Configuration example Enable the test suite in your `revolte.yaml`: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Demo-Project appName: "demo-app" config: pipeline: testSuite: command: npm run test ``` ## Automation test suite Coming Soon Expand your testing strategy with automated end-to-end and browser-based validation. This module will integrate with popular frameworks like Playwright and Cypress to provide full-system verification before every release. ## Quick links * [Code Quality](/yaml/repo-preferences/pipelines/code-quality) * [Pipelines Overview](/yaml/repo-preferences/pipelines/overview) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) # Configure Pre-build Workflows Source: https://docs.revolte.ai/yaml/repo-preferences/prebuild-workflow Configure automated code reviews, quality checks, and summarization. The **Prebuild Workflow** ensures that every Pull Request is analyzed for quality, risk, and compliance before it reaches the build stage.
## How to enable Activate AI-native code reviews and quality gates for your repository. Navigate to **YAML Configuration** > **Repo Preferences** and locate the **Prebuild Workflow** section. Toggle **Summarization** and **Fix Suggestions** based on your team's review requirements. Enter a commit message and select your target branch to persist the changes. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Pipeline controls You can toggle specific checks within your `revolte.yaml`: ```yaml revolte.yaml theme={"dark"} revolte: version: "1.0" project: Sideline HQ appName: sideline-web-admin config: codeReview: summarize: true suggestFixes: true commentStyle: Balanced ``` ## Quick links * [Agent Workflow](/yaml/repo-preferences/agent-workflow) * [Preset & Service](/yaml/repo-preferences/preset-service) * [YAML Overview](/yaml/overview) # Service Presets & Runtime Templates Source: https://docs.revolte.ai/yaml/repo-preferences/preset-service Configure automated build and deployment workflows. The **Preset & Service** settings define the automated path from a merged Pull Request to a running service in your targeted environment.
## How to enable Define your build presets and rollout strategies to automate your release cycle. Navigate to **YAML Configuration** > **Repo Preferences** and choose a build preset (e.g., Node.js, Reactjs, Nextjs) that matches your application framework. Define which environments and branches should trigger automated deployments for your services. Enter a commit message and select your target branch to persist the changes. See [Syncing Changes](/yaml/syncing) for a detailed walkthrough. ## Configuration example ```yaml revolte.yaml theme={"dark"} revolte: env: production: branch: main services: rid_1: type: WEB_SERVICE name: api-service ``` ## Quick links * [App & Branch Settings](/yaml/repo-preferences/app-branch-settings) * [Prebuild Workflow](/yaml/repo-preferences/prebuild-workflow) * [Deployments Overview](/deployments/services/overview) * [YAML Overview](/yaml/overview) # Sync Configuration Changes Source: https://docs.revolte.ai/yaml/syncing Every change you make in the Revolte UI—whether in **Repo Preferences** or **Environment Settings**—must be committed back to your repository to take effect. ## The commit process To apply your changes, you must complete the **Commit Details** workflow. This ensures that every modification is recorded in your Git history. Revolte Commit Modal ### Steps to commit 1. **Review YAML**: Review the updated `revolte.yml` configuration in the editor on the right. 2. **Enter Commit Message**: Type a description of your changes in the **Commit Message** field. 3. **Choose Branch**: Select the target branch from the **Choose Branch** dropdown menu. 4. **Finalize**: Click the **Commit** button to save your changes to the repository. **Important:** Edits made through the UI or YAML editor are not applied until they are committed. You can also choose **Skip & deploy** if you want to test changes without committing, but these will not be persisted in your `revolte.yml`. ## Manual updates If you prefer to edit your `revolte.yaml` directly in your code editor, simply commit and push your changes. Revolte will automatically detect the update and apply the new configuration.