Access Control Is Not Backup
SUMMARY
- IAM and backup do different jobs. Relying on IAM alone means risking permanent data loss, long development downtime, limited recovery options and greater damage from destructive attacks.
- These risks remain even when IAM works exactly as intended:
- authorized operations can delete or damage data,
- provider-side failures are beyond IAM’s reach,
- stolen credentials or sessions get past even strict IAM.
- IAM plus native restore and local Git clones still don’t close the gap. Native restore works only within a set window after deletion, and Git clones recover code only, without its review context.
- Even if access controls fail, a well-designed backup and recovery strategy can still prevent permanent data loss. The reverse isn’t true.
Identity and access management (IAM) can’t replace backup, because it was never designed to do backup’s job. IAM controls who can access data and what they’re allowed to do. Backup and DR provide means to recover data and resume operations when something goes wrong.
Yet at industry events, cloud architects keep putting the opposite argument to us: properly configured IAM and strict permissions eliminate the need for backups. It’s easy to see the appeal if you’ve invested heavily in access control. But it’s a bit like saying a good lock on your office door means you don’t need fire insurance.
Relying solely on an IAM system means accepting the risk of permanent data loss, prolonged development downtime, limited data recovery capabilities, and greater damage caused by ransomware or other destructive attacks.
This risk exists even when the IAM system is functioning exactly as intended.
IAM evaluates permissions, not the consequences of an operation. An authorized user or application can execute the wrong command, overwrite valid data, or corrupt it.
This is exactly what happened at Linear in January 2024. Their database migration passed local testing and was reviewed by several engineers. It included a TRUNCATE TABLE … CASCADE statement intended to clear the newly created tables before refilling them. Unfortunately, it also emptied referencing tables, deleting production data such as issue descriptions and comments.
The company was saved by restoring a full backup created a few hours earlier and then recovering the remaining data. Linear was offline for one hour, but it took 36 hours to restore 99% of the lost data. This was because, although the point-in-time restore feature was available, they had not tested it beforehand.
One could argue that stricter database permissions and additional security measures could have prevented this specific mistake, and that’s a fair point. It doesn’t change the conclusion: someone has to be able to modify production data, and authorization doesn’t make those changes correct.
The same mechanism works in your DevOps stack, all within strictly defined permissions:
- A faulty CI/CD script can overwrite valid configuration.
- An API migration can corrupt project metadata in Jira.
- Autonomous AI agents can make such changes even faster.
Your IAM can’t prevent failures on the provider’s side
Full control over your own identities doesn’t prevent administrative errors, infrastructure failures, or outages at your provider.
Take, for example, the UniSuper incident from May 2024. Google Cloud deleted a private cloud belonging to this Australian pension fund. The environment ran on Google Cloud VMware Engine. During the initial deployment, Google Cloud operators made an error that caused the private cloud to be deleted automatically after one year. It spanned two zones, and both were lost despite the distributed setup.
Backups saved the day here too: intact copies in Google Cloud Storage and in third-party backup software. UniSuper’s IAM policies had no impact on the process running on the provider’s side.
Your repositories and Jira projects also run on infrastructure you don’t control. A copy within the same service may be exposed to some of the same failures, so it needs to live somewhere else.
Outages pose another challenge. Access management won’t protect your team from them, and neither will a backup on its own, because you also need a place to keep working. However, if your backup system allows you to restore repositories to another Git platform or to a local machine, your developers can continue working even if the primary service goes down.
Strict IAM still leaves a risk of compromised access
Valid credentials aren’t always used by their legitimate owners. Attackers get in through stolen session cookies, exposed API tokens, compromised devices, or vulnerabilities in authentication software. Once they control an authenticated session or token, they may use all of its permissions.
The CircleCI security incident disclosed in January 2023 shows that risk. Malware on an engineer’s laptop stole an active SSO session that had already passed two-factor authentication. The attacker used it to access the production system. Because that engineer could generate production access tokens, the attacker was able to exfiltrate customer secrets, including environment variables and encryption keys.
CircleCI reported data theft, not destruction. But a session with write or delete permissions, compromised the same way, would let an attacker modify or destroy repositories or project data. That’s the scenario where a well-designed backup gets you back on your feet:
- Separate permissions for backup operations protect your backups from the effects of session hijacking.
- Storage outside the source environment keeps them out of an attacker’s reach.
- Immutable storage ensures their integrity until the retention period expires.
You restore the last known good state and get back to work.
Native restore and Git clones cover only part of your data
OK, I understand, but if we have a robust IAM system and use native rollback features and distributed Git, then everything is fine. We don’t need a separate backup.
Yes, native restore features and local Git clones are useful first-line recovery options, but both have limitations. They work only within a set time window or bring back only part of the data.
GitHub, for example, lets you restore deleted repositories within 90 days with restrictions on repositories in non-empty fork networks. Restoring a repository doesn’t restore team permissions.
A standard Git clone preserves the repository’s history but not the data GitHub manages, such as issues, pull request discussions, or repository settings. If you restore only the code, your engineers have to rebuild the review context by hand before work can resume.
Native repository restoration can recover more than a clone, but it remains subject to the provider’s recovery rules and service availability.
| 👉 Read also: Is GitHub a Safe Place for Your Source Code? |
Before you rely on IAM and native recovery together, check whether that combination covers all the data your team needs to keep working without disruption.
Strong IAM can’t compensate for weak backup and recovery
The idea that strong IAM makes backup optional gets the priorities wrong.
Even if access controls fail, a well-designed backup and recovery strategy can still save an organization from permanent data loss. The reverse is not true.
Strong IAM keeps the number of incidents down, but your real safety net is a backup and disaster recovery strategy that accounts for destructive operations, access breaches, and failures beyond your control. It should include:
- Point-in-time recovery, covering repositories, metadata and configuration.
- Independent storage and recovery destinations to protect against provider outages.
- Protection against deletion and tampering: Use immutable storage to safeguard backups.
- Separate access controls: Keep backup permissions independent of production access.
- Tested recovery procedures to confirm that all of this works.
GitProtect is a backup and disaster recovery solution built around these requirements. It backs up repositories and metadata from GitHub, GitLab, Bitbucket, Azure DevOps and Jira automatically.
- Point-in-time and granular restore bring back anything from a single issue to a full repository.
- During an outage, cross-platform restores let you recover to another Git platform or a local machine.
- Test restores to a sandbox let you prove the process before you need it.
- Role-based access lets teams assign separate permissions for backup operations, restores, and system administration.
- SAML-based SSO with group mapping aligns access to backups with existing enterprise identity policies.


