Start here Account Repositories Jira Sandbox Deployments Preview

i Need help? Email [support@revolte.ai](mailto:support@revolte.ai) with the error details—never share secrets or credentials.

## Access and account verification Revolte supports Google, GitHub, and email sign-up. Email sign-up cannot finish until the current one-time password is verified. **Try this** 1. Return to the sign-up screen and request a new email OTP. 2. Use only the most recently issued code. 3. If a new code does not arrive or cannot be verified, email [support@revolte.ai](mailto:support@revolte.ai). See [Account Setup & Onboarding](/get-started/account-setup) for the complete sign-up flow. ## Repository connections and configuration Direct GitHub integration is not currently available for individual developer accounts. **Try this** Contact [support@revolte.ai](mailto:support@revolte.ai) for help connecting the repository. If a custom-token connection is available for your account, follow the [Personal Access Token setup guide](/integrations/repository/github#personal-access-token). Repository setup stops when the selected branch already contains `revolte.yml`. Revolte preserves that configuration instead of creating a replacement file. **Try this** 1. Open the application from **Projects**. 2. Select **YAML Configuration**. 3. Choose the branch containing `revolte.yml`. 4. Review and update the existing configuration in the YAML workspace. See [Understanding Revolte YAML](/yaml/overview#understanding-revolte-yaml) for the configuration structure and available settings. Revolte YAML Configuration workspace showing its navigation, editor, and visual configuration panes.

Revolte YAML Configuration workspace showing its navigation, editor, and visual configuration panes.

Revolte requires a repository to contain at least one branch and one committed file. A committed `README.md` provides an explicit starting point while preserving customer-owned content. **Try this** 1. Open the repository in GitHub. 2. Create its first branch if no branch exists. 3. Add and commit `README.md`. 4. Return to Revolte and retry the connection. A personal access token can stop working when it expires, is revoked, excludes the selected repository, or lacks a required permission. **Try this** 1. Compare the token with the permissions listed in the [Personal Access Token setup guide](/integrations/repository/github#personal-access-token). 2. Confirm that the selected repository is included in the token's repository access. 3. Open Revolte **Settings** and use the PAT reset option to provide a replacement token. 4. If the repository source changed, use the GitHub migration option. See [Repository Migration](/integrations/repository/migration). 5. Retry the connection. Treat a personal access token like a password. Never paste it into Chat, support email, an issue, logs, or screenshots. ## Jira workspace connections Authorization can fail before the intended Jira site is connected when one Atlassian account has access to multiple sites. **Try this** 1. Retry with an Atlassian account that has access only to the Jira site you want to connect. 2. If the account must retain access to multiple sites, email [support@revolte.ai](mailto:support@revolte.ai) with the intended site name. See [Connect Jira](/integrations/project-management/jira) for the standard installation and authorization flow. ## Chat sessions and sandboxes A Chat session can lose its sandbox connection after an inactivity timeout or a temporary browser interruption. **Try this** 1. Select **Reconnect** when the control appears. 2. If the connection does not recover, perform a hard refresh in the browser. 3. Reopen the Chat session and confirm that the sandbox reconnects. See [Secure Sandboxes](/get-started/sandboxes#inactivity-timeout) for lifecycle and inactivity behavior. ## Give the agent a reproducible problem When a result is incomplete or an error persists, provide observable evidence. State the requested outcome, the actual result, the exact error, its location, and the checks already completed. ```text theme={"dark"} Expected result: [Describe the result that should follow the action.] Actual result: [Describe the visible result, including whether the page or URL changed.] Exact error: [Paste the complete message, or write "No error message appeared."] Location: [Name the page, component, route, or workflow stage.] Checks completed: - [First check] - [Second check] - [Third check] Use this evidence to trace the failure. Compare the delivered behavior with the requested outcome, identify the incomplete implementation, apply the smallest safe correction, and verify the affected flow. ``` ### Example: login remains on the same page ```text theme={"dark"} Expected result: After I submit valid credentials on the login page, I should reach the main dashboard. Actual result: The submit button briefly shows a loading state, but I remain on the login page and the URL does not change. Exact error: Cannot read property 'userId' of undefined Location: The login page, immediately after form submission. Checks completed: - Confirmed that the credentials are correct - Confirmed that the form values are saved - Reproduced the issue in another browser ``` ### Collect useful evidence 1. **Capture the first error.** Copy the complete message from Revolte, Preview, the browser console, or application logs. 2. **Describe the difference.** Record the expected and actual states after the same action. 3. **Record an unresponsive action.** Name the control, the expected transition, and what remained unchanged. 4. **Send one focused request.** Use the template above to keep the investigation tied to a reproducible failure path. ## Release and deployment recovery A failed deployment includes build or runtime context that can be returned to Chat for a targeted correction. **Try this** 1. Open the failed deployment. 2. Select **Fix with AI**. 3. Review the deployment details transferred into Chat. 4. Apply the proposed correction and retry the deployment. Use [Deployment Logs](/deployments/observability/deployment-logs) to follow build and runtime activity. Deployment remains unavailable when an environment in `revolte.yml` lacks a valid branch mapping or service definition. **Try this** 1. Open **YAML Configuration** for the application. 2. Select the branch used by the affected environment. 3. Resolve each validation message shown in the editor. 4. Save and commit the corrected configuration. 5. Return to the deployment page and retry. See [Common YAML validation errors](/yaml/repo-preferences/common-errors#common-validation-errors) for missing branch and service-property examples. Revolte YAML Configuration workspace used to review branch, environment, and service settings.

Revolte YAML Configuration workspace used to review branch, environment, and service settings.

## Building and previewing your app Preview can continue showing an earlier version while files are still changing, the build is still running, or the editor and Preview are using different branches or sessions. **Try this** 1. Confirm that the current change and Preview build have completed. 2. Verify that the editor and Preview use the same branch and active session. 3. Refresh Preview. 4. If it is disconnected, select **Reconnect** and perform a hard refresh if necessary. A `404 - Page Not Found` response can appear when code changes are still in progress, the Preview build has not finished, or the requested route is not present in the generated result. **Try this** 1. Check whether code changes or the Preview build are still in progress. 2. Wait for completion, then select **View Preview** again. 3. If the `404` remains, capture the exact URL and error message. 4. Send both to the Revolte agent and request verification that the route, page file, and navigation target satisfy the requested behavior. A rendering failure can leave Preview blank or prevent the requested interface from appearing. **Try this** 1. Capture the complete error shown in Preview, including the page and action that produced it. 2. Send the error to the Revolte agent without shortening or rewriting it. 3. Request a comparison between the delivered behavior and the requested outcome, followed by a focused correction. 4. Reopen **View Preview** and verify the affected page. A request may be applied to only part of a page or to a different component than intended when the target and expected state are not specific enough. **Try this** 1. Name the exact page and component. 2. Describe its current state and the intended state. 3. Include a screenshot or exact error when available. 4. Request a focused update that reuses the repository's existing components and design system. Differences in layout, spacing, typography, or responsive behavior are easier to correct when they are tied to a specific frame and measurable visual details. **Try this** 1. Confirm that Revolte can access the Figma file and intended frame. 2. Name the frame and the mismatched components. 3. Record measurable differences such as spacing, alignment, dimensions, and breakpoint behavior. 4. Request an update that uses the repository's existing components and tokens while matching the supplied design. See [Figma to Code](/use-cases/figma-to-code) for the recommended workflow. ## Contact Revolte support Email [support@revolte.ai](mailto:support@revolte.ai) when the workflow remains blocked. Include: * The affected workspace and project name. * The page or workflow stage where the problem occurred. * The exact error and when it appeared. * A screenshot with credentials and personal information removed. * The recovery steps already completed. Do not send passwords, email OTPs, GitHub personal access tokens, API keys, or other credentials. # 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) # 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. 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](/get-started/quickstart) * [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 using logs, stack traces, and repro steps. 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. 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) # 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. 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) * [Automated Quality Validation](/archive/ai-workflows/quality-assurance) Coming Soon # Trace and Fix an End-to-End Workflow Source: https://docs.revolte.ai/use-cases/trace-a-workflow Follow an execution path across services and queues to find where it breaks, then fix it and add end-to-end test coverage. Complex features often span multiple services, message queues, and database updates. When an end-to-end flow fails, finding the broken link takes more time than writing the fix. This walkthrough uses Revolte to trace execution paths across your architecture and land targeted fixes. ***

Start by asking Revolte to follow a request from entry point through all downstream systems. ```text theme={"dark"} Trace the order fulfillment workflow starting from POST /api/v1/orders. Follow: - API route handler and validation. - Event publication to the message queue. - Worker queue consumer and inventory checks. - Payment gateway interaction. - Database updates and notification triggers. Map the end-to-end path and highlight potential points of failure. ``` Revolte maps the full execution chain across files and services, identifying where states get dropped, timeouts occur, or unhandled errors block completion. ```text theme={"dark"} Breakdown identified: When inventory reservation times out, the worker queue consumer fails silently without publishing the order.failed event. Downstream notification services never trigger, leaving the order stuck in PENDING. ``` Tell Revolte to fix the failure handling and add tests for the complete flow. ```text theme={"dark"} Fix the timeout handling in the worker queue consumer: - Catch inventory reservation timeouts. - Publish the order.failed event with the appropriate error payload. - Mark the order status as FAILED in the database. Verification: - Add integration tests for the timeout scenario. - Confirm existing successful order flows still pass. ``` With the workflow mapped, easily add resilience improvements: * "Add retry logic with exponential backoff for inventory checks." * "Implement a dead-letter queue handler for unrecoverable fulfillment errors."

*** ## Related * [Investigate and Fix a Production Bug](/use-cases/fix-a-bug) * [Build APIs from a Spec](/use-cases/api-from-spec) # Add Files and Context Source: https://docs.revolte.ai/workflows/add-files-and-context Attaching explicit files, specs, and design documents to guide AI tasks by targeting specific paths and example implementations. Adding files directly to a task is coming soon. Until then, reference relevant repository paths and include essential requirements in your prompt. Provide Revolte with specific target files or external design documents to narrow context: * **Target Specific Paths**: `@src/services/auth.ts` to lock execution scope. * **Attach Design Specifications**: Include Markdown files or OpenAPI schemas in your prompt. * **Reference Example Implementations**: Point Revolte to existing modules that serve as structural patterns. # Build from a Prompt Source: https://docs.revolte.ai/workflows/build-from-prompt How to drive software feature development directly from natural language prompts by describing behavior and constraints clearly. Prompt-driven development is the core workflow in Revolte. You describe desired functionality, architectural constraints, or bug fixes, and Revolte parses your repository to plan and execute the code changes. ## Effective Prompting Strategies * **Be Specific About Behavior**: Describe inputs, outputs, and expected edge cases. * **Reference Existing Patterns**: Mention existing utility functions or styling conventions. * **Set Technology Constraints**: Specify versions, packages, or API standards. ```text theme={"dark"} Create a new endpoint GET /api/v1/projects/:id/health that queries the database for service metrics, formats the response using the standard API Envelope schema, and logs errors using the app logger. ``` # Build an App with Interactive Chat Source: https://docs.revolte.ai/workflows/chat-feature Describe an application, refine its requirements, review generated code, commit the result, and validate it with Revolte Interactive Chat. Open Revolte, start a new chat, and confirm that **Interactive** mode is selected. In the prompt box, describe the application and list its essential features. For example: “Build a responsive chat application with conversation search, message timestamps, and a typing indicator.” Open the model selector and choose the model Revolte should use for the task. Choose the CPU and memory size for the sandbox. Use a larger sandbox for workloads with heavier builds, dependency installation, or memory-intensive tests. Revolte builds and runs the application in an isolated environment, keeping agent activity separate from your local machine and shared environments. Submit your request. Revolte provisions the sandbox and begins working on the application. Wait until the **Sandbox Environment** status shows **Active**. If Revolte asks a clarifying question, select one of the suggested answers or enter your own response. Continue until the requirements reflect the result you want. Revolte asks focused questions when a requirement is ambiguous, reducing assumptions before more code is changed. Open the **Code** panel to inspect the files Revolte created or modified. Review the file tree and code, and make any necessary edits directly in the sandbox. Open the **Commit** panel, expand a file under **File changes**, and use the **Inline** or **Split** view to inspect every addition and deletion before committing. Open the **Commit** panel and review the changed files. Enter a clear commit message, then select **Commit and Push** to send the changes to the connected repository. After committing the change or reviewing the resulting pull request, open the secure, sandbox-backed VS Code workspace. Use the familiar Explorer, Source Control, editor, and terminal tools to inspect or update files without leaving Revolte. Open **Live Preview** and interact with the running application in the sandbox. As you edit the code, hot reload refreshes the preview so you can validate changes immediately. ## Next steps Move your committed Chat work into a managed Preview environment and validate the deployed application. * [Learn more about AI Chat](/get-started/ai-chat) * [Understand sandbox environments](/get-started/sandboxes) * [Build from a Prompt](/workflows/build-from-prompt) # Connect a Git Repository Source: https://docs.revolte.ai/workflows/connect-git-repository Give Revolte secure access to the codebase context it needs to plan, implement, and deliver changes. Connect a repository before asking Revolte to change existing code. The selected repository gives the agent the project structure, dependencies, and established implementation patterns needed for grounded work. During application setup, select the repository connection action. You can also connect a repository when a new chat needs codebase access. Select **GitHub**, then select **Proceed**.

The Connect your repository dialog with GitHub available for selection.

Complete the GitHub authorization flow and grant access only to the repositories Revolte should use. Associate the repository with your Revolte application. When you start a task, Revolte can read the connected codebase, follow its existing patterns, and prepare changes against the selected branch. Repository access also allows completed work to move into your normal Git workflow as a reviewable commit or pull request. For provider-specific setup, see [GitHub Integration](/connect/github). # Connect Jira to Autopilot Source: https://docs.revolte.ai/workflows/connect-jira Connect Jira so a ticket can provide requirements and start work against the correct Revolte application. Connect Jira when your team wants to start autonomous work from its existing backlog. The Jira ticket supplies the request, while the selected Revolte application identifies the codebase that should be changed. In Revolte, open **Chat**, select **Autopilot**, and begin the Jira integration step. The Autopilot setup screen showing Jira Integration as the first setup step.

The Autopilot setup screen showing Jira Integration as the first setup step.

Install the Revolte app from the Atlassian Marketplace, review the requested permissions, and select the Jira site your team uses. Return to Revolte and confirm that **Jira Integration** shows a green checkmark and the connected site name.

The Autopilot setup checklist showing Jira integrated successfully.

After setup, open a Jira ticket, choose the target application from the **Revolte** panel, and follow the triggered workflow in Revolte. For the full installation and ticket-trigger flow, see [Connect Jira](/integrations/project-management/jira). # Continue Existing Work Source: https://docs.revolte.ai/workflows/continue-previous-work Continue with an existing application, create another application, or return to a previous task from Chat or All Projects. Returning users can start from an application that already exists or create a new application from **All Projects**. Select **Chat** from the left navigation.

The Chat item in the Revolte navigation.

Open the application selector below the prompt composer, then choose the application you want to work with from **Application list**. Interactive Chat with the Application list open and an existing application available to select.

Interactive Chat with the Application list open and an existing application available to select.

Select a branch, describe the next change, and submit your prompt. Revolte starts the work with the selected application's repository context. Select **All Projects** from the left navigation. Existing projects and applications appear on this page. The All Projects page with an existing project and the Create App button.

The All Projects page with an existing project and the Create App button.

Click **Create App**, choose an existing project or create a new one, and connect the repository the application should use. Return to **Chat**, select the new application from **Application list**, choose a branch, and submit your prompt. Selecting an application starts work with its repository context. To reopen the same earlier conversation, open the task from your task history. ## Continue an earlier task You can resume or iterate on a previously executed Revolte task using: * **Follow-up Instructions**: Provide additional instructions to refine an existing diff. * **Branch Resume**: Select an existing Revolte branch to append new commits. * **Task History**: Access complete step-by-step logs and transcripts from past sessions. # Workflow Overview Source: https://docs.revolte.ai/workflows/overview Understand how Revolte moves work from a request to a reviewable code change, using interactive chat or an autonomous Jira-triggered workflow. Revolte supports two ways to build software: work interactively in chat or trigger an autonomous workflow from Jira. Both paths use repository context, isolated execution, and a review step before changes enter your delivery process. Shape the requirement with Revolte, follow implementation, and review the result in one conversation. Start work from a Jira ticket and follow the autonomous run through planning, implementation, and review. ## The common workflow Start with a prompt or Jira ticket that explains the expected outcome, constraints, and success criteria. Select a connected repository and add any paths or requirements that help Revolte understand where the change belongs. Check the proposed plan, affected files, and validation steps before accepting the implementation direction. Revolte works in an isolated sandbox, where it can inspect files, make changes, and run checks without modifying your local workspace. Review the changed files, code diff, validation output, and live preview when one is available. Commit the approved work or continue through your team's pull request and deployment process. Choose [Build with Interactive Chat](/workflows/chat-feature) for collaborative work, or [Automate Work from Jira](/workflows/your-first-Autonomous-workflow) when the requirement is already managed in Jira. ## Coming Soon * [Quality Assurance Gates](/archive/ai-workflows/quality-assurance) Coming Soon * [Product Strategy Automation](/archive/ai-workflows/product-strategy) Coming Soon # Review Code Changes Source: https://docs.revolte.ai/workflows/review-ai-changes Inspect the files changed by an Autopilot run before accepting the result, using the diff summary and verification checklist. After execution completes, compare the implementation with the approved requirement and plan. In the workflow run, select **Artifacts**, then open **Diff Summary**. The Diff Summary tab showing the files modified by an Autopilot run.

The Diff Summary tab showing the files modified by an Autopilot run.

Review modified, created, and deleted files. Check that each change is required by the ticket and follows the repository's existing patterns. Review the completed stages and validation output before continuing to the pull request or deployment preview. ## Verification Checklist * [ ] All modified lines follow project code standards. * [ ] Automated tests pass cleanly. * [ ] No extraneous file changes or unused imports were introduced. * [ ] The implementation satisfies the Jira ticket or original request. # Review the Execution Plan Source: https://docs.revolte.ai/workflows/review-execution-plan Understand the proposed approach, affected files, and validation steps for an Autopilot run before implementation begins. The execution plan explains what Revolte intends to change and how it will validate the result. Open the Jira-triggered workflow in Revolte, then select **Artifacts**. Select **Plan** to review the codebase background, implementation subtasks, proposed file changes, and verification plan. The Artifacts view showing an implementation plan for a completed workflow run.

The Artifacts view showing an implementation plan for a completed workflow run.

Confirm that the plan addresses the ticket, follows the existing architecture, and includes the checks needed to validate the change. ## Key Plan Components * **Background:** The relevant codebase structure and existing implementation patterns. * **Subtasks:** The ordered work Revolte performed or proposes to perform. * **Proposed changes:** The files and behavior affected by the implementation. * **Verification plan:** The tests and checks used to validate the result. Next, [review the resulting code changes](/workflows/review-ai-changes). # Work with Existing Code Source: https://docs.revolte.ai/workflows/work-with-existing-code Refactoring, updating, and extending established codebases with Revolte while preserving conventions and dependency awareness. Revolte is engineered to work inside existing codebases of any scale. ## Codebase Context Indexing When attached to a repository, Revolte indexes symbols, module dependencies, and configuration schema to preserve your architecture: * **Preserves Conventions**: Adheres to existing linter settings, naming conventions, and file structures. * **Dependency Awareness**: Automatically imports utility modules and helper functions without duplicating code. * **Safe Refactoring**: Traces invocation sites across the project when signatures change. # Jira Workflow Source: https://docs.revolte.ai/workflows/your-first-Autonomous-workflow Set up and run your first Jira-connected autonomous development workflow, from integration setup to status transition mapping. 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](/get-started/quickstart) guide. Navigate to the **Chat** section and select **Autopilot**. Connect your Jira workspace by installing the Revolte app from the Atlassian Marketplace, accepting the requested permissions, and selecting the Atlassian site to install to. For the full step-by-step walkthrough, see [Connect Jira](/integrations/project-management/jira). Once your Jira integration is complete, carry on with the remaining steps in the setup flow: complete **Git Integration** to connect your repository, **Configure Application** to define your app's service details, and **Commit YAML** to save your `revolte.yml` configuration. Once all four steps show a green checkmark and your configuration has been committed, you're ready to set up the workflow. Click **Configure workflow** to proceed. 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, such as *To Do* to *In Progress*, and completion, such as *Done*. * **Target Branch**: Specify the branch where AI changes should be proposed, such as `qa` or `main`. * **Model Mode**: Select based on your needs, such as `Claude Haiku - Fast & efficient`. 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 **View Workflow Details** 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 * [Workflow Overview](/workflows/overview) * [Quality Assurance Gates](/archive/ai-workflows/quality-assurance) Coming Soon * [Product Strategy Automation](/archive/ai-workflows/product-strategy) Coming Soon # Environment Configuration Source: https://docs.revolte.ai/yaml/environment-settings/overview Manage service-specific configurations for Production, UAT, QA, and Preview environments, including variables and limits.

**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, including code review, code quality, and test suite quality gates in revolte.yaml.

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/pipelines/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 and an eviction policy to ensure low-latency data retrieval in production. ## 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 persistent storage, IOPS, and instance sizing for your managed database services based on workload needs. 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 scalable object storage buckets for assets, backups, and user uploads, including versioning and access policy. 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 securely inject secrets into your revolte.yaml services using the dashboard Secret Engine. 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 like React, Vue, and Next.js with CDN delivery, routing, and environment variable 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 CPU, memory, and storage allocation for web-facing services, with recommended sizing for production and staging. 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 the Agent Workflow so Revolte's AI agent can assist directly within your repository for 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 map Git branches to Production, UAT, and QA environments for deployments.

## 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 Configuration Errors Source: https://docs.revolte.ai/yaml/repo-preferences/common-errors Resolve common revolte.yaml validation errors, including missing branch mappings and service definitions in Repository Preferences. ## 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, static analysis, and rule severity levels so every commit meets your coding standards. **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 Configure Code Quality and Test Suite pipeline stages, plus 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 in your pipeline, including execution triggers and run policies. **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 the Prebuild Workflow to run AI-native code reviews, PR summarization, and quality gates before every build. 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 build presets and service mapping to automate the path from a merged pull request to a running deployment. 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.

AI is changing more than how code gets written.

01 / THE ENGINEERING LIFECYCLE

02 / REVOLTE WORKFLOWS

Where a workflow can start

What a workflow coordinates

03 / HUMAN-IN-THE-LOOP

How Revolte shapes the developer's day

Beyond AI coding

Continue in the docs

Getting Better Results with Revolte

Revolte Starter Tasks

The AI Engineering Workspace from Intent to Shipped Code.

Software Engineering, Reimagined

Tools for the Way You Engineer

What You Can Build

Three Ways to Work

Integrated Cloud Platform

Where to Go Next