> For the complete documentation index, see [llms.txt](https://docs.firefly.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.firefly.ai/key-features/backup-and-dr.md).

# Applications Backup & DR

The Applications Backup & DR feature enables you to back up, monitor the backup process for, and restore your applications and the infrastructure they depend on using an Infrastructure‑as‑Code (IaC)–first approach.

Firefly automates the discovery of application blueprints — the cloud services, dependencies, and configurations an application is built from — and orchestrates their protection and recovery, in line with Gartner's Cloud Application Infrastructure Recovery Solutions (CAIRS) category.

## Overview

Applications Backup & DR helps teams:

* Group cloud resources into applications and discover their full dependency graph
* Choose the right protection level per application — from a logical grouping only, through configuration backup, up to fully automated recovery
* Gain clear visibility into snapshots, restore coverage, and backup health
* Recover predictably by restoring infrastructure as Terraform
* Keep environments consistent under pressure with IaC‑first disaster recovery

This approach ensures consistent, repeatable recovery workflows during incidents.

## The Applications Page

Go to **Recover → Applications** to see all applications in your organization. For each application the table shows its protection status, **Restore Coverage** (the share of its assets that recovery automation can fully rebuild), **Recovery Readiness**, data source, region, scope filters (tags or clusters), snapshot count, and the time of the last backup. From this page you can trigger an on‑demand backup (**⋮ → Backup Now**), edit an application's settings, or create a new application.

**Recovery Readiness** shows at a glance whether an application's recovery automation is ready to run:

* 🟢 **Green** — all required recovery inputs are filled.
* 🟠 **Orange with `!`** — recovery inputs are missing. Hover over the status bar to see how many inputs are missing and use the **Complete setup →** link to open the Required Inputs editor.
* ⚪ **N/A** — the application has no recovery automation.

## The Application Page

Opening an application shows its details in tabs: **Overview**, **Snapshots**, **Recovery Posture**, **Test Runs**, and **Required Inputs** (the last two appear for Recovery Automation applications).

* **Backup Now** — a button anchored in the application page header (visible across all tabs for protected applications) triggers an instant snapshot and refreshes the **Snapshots** tab and the **Last Backup** indicator. The button is disabled while a backup is already running. If required recovery inputs are missing, an **Input required** pill appears in the header.
* **Recovery Posture** — the policy violations that put this application's recovery at risk, scoped automatically to the application's assets (no need to filter the general Policies screen). The tab shows:
  * A **Resiliency Posture score** for the application, with the number of violated policies and how many are critical — for example, *66% · 8 violated policies · 0 critical*.
  * **Top Risks Blocking Recovery** — the critical issues that would stop a successful restore.
  * Category tiles — **Backup, Reliability, Availability, Misconfiguration, Insecure Configurations** and **Observability** — each with its violation count and worst severity.
  * A policy table scoped to the application, with severity, data source, affected asset types, a compliance bar, links to the violating assets, notification and enable/disable controls, and one-click **AI remediation**.
* **Required Inputs** — fill in the values recovery automation needs, instead of editing the generated `tfvars` file by hand. Variables are grouped into categories with search, filters and expand/collapse. Values are edited in a modal and validated against the expected format; sensitive values can be shown or hidden and saved secrets display as protected. The tab appears only for Recovery Automation applications.

## Protection Types

Every application has one of three protection types, selected in the **Resilience** step of the creation wizard:

| Protection type                    | What it does                                                                                                                                                                                                                                                              | IaC generation |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
| **Recovery Automation**            | Everything in Configuration Backup, plus automated rebuild of the application to a recovery target account during outages and attacks. On every snapshot, Firefly generates the IaC for the application and opens a pull request with a Plan workflow in your repository. | Yes            |
| **Configuration Backup** (default) | Scheduled snapshots of the application's configuration for point‑in‑time restore. Each snapshot is compared to the previous one (or to the baseline) so you can track exactly what changed. No IaC is generated and no recovery target is configured.                     | No             |
| **No protection**                  | The application is created as a virtual grouping only — a logical "group by application" across Firefly pages. No snapshots are taken. You can enable protection later from the application settings.                                                                     | No             |

> **Note:** Recovery Automation is available for applications running on AWS, Azure, and Google Cloud. All platforms support Configuration Backup and virtual grouping.

## Creating an Application

To create a new application, go to **Recover → Applications** and click **+ Application**. The wizard walks you through five steps: **Application Scope**, **Discovery**, **Resilience**, **Restore Validation**, and **Completion**.

### Step 1: Application Scope

Identify your application and the cloud resources it spans:

* **Application name** (required) and an optional description
* **Platform** — select where the application runs: AWS, Azure, or Google Cloud, or choose **Show more** for additional platforms such as OCI, vSphere, Kubernetes, Nebius, Datadog, New Relic, Okta, Entra ID, Microsoft Teams, GitHub, Cloudflare, NS1, PagerDuty, MongoDB Atlas, Vault, Akamai, and Databricks
* **Scope** — the **Account** and **Region** where the application is deployed
* **Scope Filters** — **Tags** (at least one key‑value pair is required) that narrow down which resources are included in the application. For Google Cloud applications, label filters are optional — leave them empty to include the complete project, which can later be restored in full to another project

> **Tip:** Have resources the scope doesn't catch? You can assign them to the application from the Inventory once the application is created.

### Step 2: Discovery

Firefly scans the cloud account and lists every resource that matches the application scope, grouped by asset type. Review the discovered resources and use the checkboxes to include or exclude asset types or individual resources before continuing.

**IaC Siblings:** Firefly also surfaces resources that are **managed together by the same IaC stack** as the resources in scope ("siblings"). Because Firefly understands the code that manages your infrastructure, it knows which resources live together — so related resources are suggested automatically instead of being added one by one, and nothing is missed from the protection scope. Review the suggested siblings and include the ones that belong to the application. The same interactive flow is available when editing an existing application's scope.

When the scope targets an application component (for example, an EC2 instance), Firefly automatically captures all required relationships and dependencies needed to restore the application correctly, such as the VPC, subnet, and IAM instance profile. Resources that are implicitly created as part of these relationships are not backed up separately, as they are recreated during restoration.

**The following assets are not eligible for backup:**

* Deleted assets
* Assets in an undetermined state

### Step 3: Resilience

Define how the application is protected and where it can be recovered.

The **Protect this application** toggle controls whether the application is protected at all. Switching it off creates the application as a virtual grouping only (the **No protection** type) — the Restore Validation step is skipped and you can create the application immediately.

With protection enabled, choose the **Protection level**: **Configuration Backup** or **Recovery Automation** (see [Protection Types](#protection-types) above).

**Recovery objective (RTO):** set the recovery time objective for the application. Firefly schedules configuration snapshots at half the selected RTO — for example, an RTO of 4 hours takes a snapshot every 2 hours, and an RTO of 12 hours takes a snapshot every 6 hours. A lower RTO means more frequent snapshots and lower configuration loss.

For **Recovery Automation**, also configure:

* **Recovery target** — the destination integration (account, subscription, or project) and region where the application will be recovered. For Google Cloud, choose between keeping the same regions as the source when restoring to another project (a Google Cloud VPC is global and can span multiple regions) or restoring everything into a single region. In both cases Firefly shows a preview of the planned changes before anything is committed to the target project. Firefly restores with the integration's [write credentials](https://docs.firefly.ai/detailed-guides/workflows/cloud-credentials.md). If the selected integration has no write credentials, the wizard warns that Firefly can't restore into this target until they are added; click **Add write credentials** to add them on the integration, then **Check again**
* **Version Control & Workspace** — the VCS integration and repository (required), target branch, working directory, and workflow project. On every snapshot, Firefly automatically opens a pull request with the snapshot manifest and runs a Plan workflow in the selected repository.

**Notifications** are optional for both protection levels — select a destination to stay informed about backup and recovery events, or configure them later.

### Step 4: Restore Validation

Firefly checks whether recovery automation supports every asset type discovered in the application, and shows:

* How many asset types are covered by recovery automation, with the number of assets that are **fully recoverable** versus **backed up only**
* The asset types not yet supported by recovery automation — these are still captured in configuration backup, so their configuration can be restored, but Firefly will not rebuild them automatically in the recovery target. Use **Request support** to ask for coverage of an asset type you need
* The asset types supported by recovery automation

For applications using Configuration Backup, this step is informational only — restore validation applies only to applications with Recovery Automation enabled.

### Step 5: Completion

Review the summary of the new application — the RTO, the source environment (account and region), and, for Recovery Automation, the target environment — and click **Create**.

## Comparing Snapshots

Every snapshot is automatically compared to the snapshot taken immediately before it. The result is stored with the snapshot and appears in the **Changes** column of the Snapshots tab as a delta bar showing how many resources were added, removed, and changed. The first snapshot of an application has nothing to compare against and is labelled **Baseline**.

To compare two snapshots directly:

1. Open the **Snapshots** tab of the application
2. Select the checkboxes of the two snapshots you want to compare
3. Click **Compare**

The comparison opens in a modal grouped into **Added**, **Removed**, and **Configuration Change**, with the asset type tagged per resource and a line-level view of the configuration JSON for changed resources. Comparison is available only between snapshots of the same application.

### AI Analysis

Select **AI Analysis** in the comparison modal header to generate a plain-language summary of the comparison — for example, whether the changes are configuration-only or potentially destructive. The summary is generated only when you select it; it does not run automatically.

### Deleting a Snapshot

Deleting a snapshot removes its configuration data and its own comparison result. The comparison that belongs to the **next** snapshot is kept — Firefly never recalculates it against a different snapshot and never removes it in the background.

When you open a comparison whose earlier snapshot has been deleted:

* The modal title shows that snapshot's timestamp dimmed, followed by a **Deleted** tag
* The line *Stored comparison — cannot be recomputed.* appears below the title
* Hovering the **Deleted** tag shows when the snapshot was deleted and by whom

The comparison itself still works in full, including AI Analysis, because the result was stored when the snapshot was created. In the Snapshots tab the Changes column is unchanged; hovering the delta bar notes that the comparison was made against a snapshot that has been deleted.

Deleting the oldest snapshot does not promote the next one to **Baseline** — the next snapshot keeps its stored comparison.

Before deleting, the confirmation dialog states how many comparison results will be removed and how many later snapshots will keep theirs marked as compared against a deleted snapshot. Deletion cannot be undone.

## Restoring Applications

Applications are restored by generating Terraform code, rather than performing direct cloud mutations.

### Restoring from a Snapshot

To restore resources:

1. Open a snapshot
2. Select one or more resources
3. Click **Restore Selected**
4. Preview the generated Terraform code
5. Continue with Firefly's IaC orchestration flow

This ensures restored resources remain:

* Fully codified
* Auditable
* Aligned with existing IaC standards

## Common Use Cases

* Recover infrastructure after accidental deletion
* Restore a subset of resources without impacting the entire environment
* Recreate infrastructure in a different region using Terraform
* Validate backup coverage and compliance across teams

## Notes & Limitations

* Recovery Automation is available only for AWS, Azure, and Google Cloud applications
* Snapshots are taken only for applications with protection enabled (Configuration Backup or Recovery Automation); applications created without protection are virtual groupings only
* Restoration availability depends on Terraform provider support
* Large snapshots may take longer to load resource inventories
* Snapshot comparison is available only between snapshots of the same application
* A stored comparison cannot be recomputed after either snapshot is deleted
* Deleting a snapshot is permanent; snapshots and their own comparison results cannot be restored

***

Applications Backup & DR provides a safety net for your cloud infrastructure by ensuring you can quickly recover from incidents while maintaining consistency with your Infrastructure as Code practices. By treating disaster recovery as code, teams can test, version, and automate their recovery procedures just like any other infrastructure component.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.firefly.ai/key-features/backup-and-dr.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
