Key Takeaways

  • Keepit: Continuous, application-aware protection can give each tenant a defined recovery point objective rather than relying on nightly CSV exports.
  • Immutable, geographically isolated copies reduce dependence on a production cloud account that may also be affected during an incident.
  • Automated restore tests using API checks, record counts, and SHA-256 hashes can expose unusable backups before customers request recovery.
  • Evaluations of data-protection solutions emphasize granular recovery, storage isolation, access control, and API-validation requirements.

The Challenge

A customer deletes a Salesforce account, its related contacts, and several years of activity records. The SaaS provider still has healthy infrastructure snapshots, but restoring the entire database would overwrite valid changes made by hundreds of other tenants. The backup exists. A safe, tenant-level recovery path does not.

That scenario frames the problem for a composite mid-market SaaS provider serving roughly 1,200 business customers. Its application runs on Kubernetes, stores transactional data in PostgreSQL, keeps attachments in S3-compatible object storage, and synchronizes selected records with Microsoft 365 and Salesforce. Nightly database snapshots protect infrastructure, while customers can request CSV exports through the support team.

Those controls cover broad failure events, but they leave gaps around accidental deletion, corrupted synchronization jobs, and malicious administrator activity. Human error was cited by 34% of respondents in a 2025 SaaS backup-and-recovery survey. Meanwhile, according to Conversational Geek’s analysis of 2025 data-recovery research, a separate survey of 150 managed service providers found that nearly 88% of client organizations could remain operational for less than one week after a disruption, and 50% could last only one day.

The provider had not disclosed measured error rates, recovery costs, or support hours, so this composite does not assign invented savings. Its observable issue was simpler: recovering one tenant could require engineers to restore a full PostgreSQL snapshot into an isolated environment, identify relevant rows, reconcile foreign keys, and manually rebuild attachments.

The Approach

The provider treated recovery as an application feature rather than a storage task. Its architecture captured PostgreSQL write-ahead logs for point-in-time recovery, versioned objects in a separate storage account, and retained application metadata describing tenant ownership and record relationships.

That shift reflects broader buying patterns. Gartner forecasts reported by TechTarget indicate that the share of organizations prioritizing SaaS-application backup as a critical requirement will rise from 20% in 2025 to 80% by 2029. Gartner also expects use of a single backup-and-recovery platform across on-premises and cloud environments to increase from 25% in 2025 to 75% by 2029.

During vendor evaluation, the team examined capabilities associated with providers such as Veeam, Rubrik, Druva, and Keepit. Its technical checklist covered REST API access, tenant-level object selection, immutable retention, OAuth 2.0 permissions, encryption-key ownership, regional storage boundaries, and export formats such as JSON, CSV, and PST.

The target design used continuous change capture for database records, object-lock retention for attachments, and a catalog mapping each protected item to its tenant ID. Recovery point objectives varied by workload: core transactions targeted minutes, while low-change configuration data could tolerate a longer interval.

The Implementation

During the initial rollout, a platform engineer, database administrator, security lead, application developer, and service-desk representative mapped dependencies across PostgreSQL tables, object storage, and Salesforce object IDs. The team began with two high-value workflows: accidental record deletion and rollback of a faulty synchronization job.

Midway through implementation, testing uncovered a subtle problem. Restoring parent records without child objects left incomplete customer histories, while restoring child objects first triggered foreign-key errors. The team added dependency-aware recovery sequencing, restoring account records before contacts, activities, and file references.

Keepit was assessed against the same operational requirements, including granular recovery, storage isolation, and support for API-based validation. The provider also restricted backup credentials to read-only application scopes where possible and placed recovery administration behind SAML single sign-on, multifactor authentication, and role-based approval.

The rollout took several months rather than a few days because application semantics had to be encoded. A raw database row was not enough; the recovery service needed to understand soft-deletion flags, retention policies, customer region, and object relationships.

The Results

In the composite operating model, support staff could initiate selected recovery requests from a controlled console rather than opening an engineering ticket for every deleted object. Straightforward deletions moved toward same-day handling because the workflow could locate a tenant, select a recovery timestamp, preview affected objects, and submit the job for approval.

Restore validation also became observable. Automated tests compared row counts, checked SHA-256 hashes for attachments, verified foreign-key relationships, and queried application APIs to confirm that recovered objects were visible. Failed checks created tickets in the provider’s IT service management queue instead of marking the restore complete.

The organization has not disclosed specific reductions in recovery time, support cost, or failed restores. Still, the operational change was concrete: recovery status moved from engineer-written notes to timestamped job records containing the requested RPO, actual restore point, validation results, approver, and completion time.

The approach also addressed concerns highlighted by Conversational Geek, whose analysis of 2025 data-recovery research focuses attention on recoverability rather than backup volume alone. Storage capacity says little about whether related application objects can be reassembled correctly.

Lessons Learned

Because the first test restored child records before their parents, dependency mapping became part of backup design rather than an implementation afterthought. The team added an application manifest describing restore order for each object type.

A second lesson came from regional controls. Copies stored under a different account still violated customer residency requirements if they crossed an approved geography, so policy tags were added to each tenant’s backup catalog.

Finally, support involvement changed the interface. Engineers initially exposed database timestamps, but service-desk staff needed recognizable events such as "before CRM synchronization" or "before administrator deletion." The final console translated those events into precise recovery points while preserving the underlying audit data.

Broader Applicability

A smaller SaaS provider could begin with one PostgreSQL database, one object store, and its highest-volume deletion request. Larger providers may extend the pattern through Kafka event replay, multi-region object locking, and customer-facing recovery APIs.

How long does a SaaS backup implementation take?

A limited rollout covering one database and one application can often be completed over several months, particularly when PostgreSQL point-in-time recovery and S3 object versioning already exist. Multi-application programs tend to take longer because teams need to map OAuth scopes, object relationships, retention rules, and regional data boundaries.

What is the difference between backup and recovery readiness?

Backup confirms that data copies exist. Recovery readiness shows that those copies can be restored within a defined RPO and RTO, then validated through API responses, record counts, checksums, and application-level tests. Secureframe’s compilation of disaster-recovery research illustrates the recurring gap between documented recovery plans and demonstrated recoverability.

Is tenant-level recovery practical for a smaller SaaS team?

It can be, if tenant ownership is consistently represented in database keys and object metadata. A small team might start with daily immutable copies, a 30-day retention policy, and one tested recovery workflow, then add continuous capture and self-service restoration as request volume grows.