Root Email, MFA and API Keys: Securing an Inherited Account
Credential hygiene for an account someone else created. Covers the root mailbox, replacing authentication factors, closing recovery paths and rotating keys without downtime.
Every credential on an inherited account was created by someone who is not you. That single fact drives everything in this guide. You are not hardening a system you built, you are establishing exclusive control over one that already has a history, and the two jobs need different instincts.
The focus here is narrow on purpose: identity, authentication factors and programmatic credentials. The broader operational sweep, covering billing alarms, network exposure and leftover resources, belongs to the post handover checklist. What follows assumes you have console access and want to turn that into control nobody else shares.
Why inherited credentials are a different problem
When you build an account yourself, you know the set of things that hold credentials because you created each one. With an inherited account, the set is unknown and you are working backwards. Absence of evidence is not evidence of absence: a key you cannot find is not a key that does not exist.
So the approach is systematic rather than intuitive. Enumerate every mechanism the provider offers for authenticating to the account, check each one, and treat anything you did not create as hostile until proven otherwise. The mechanisms usually number fewer than ten per provider, which makes this a finite job rather than an endless one.
It also helps to decide up front what “done” looks like. A reasonable definition: every path into the account terminates at something you control, every credential has a known owner and purpose, and the audit log shows no successful authentication you cannot attribute. Write that down before you start, because without a finish line this work expands indefinitely and people abandon it half complete, which is the worst of both outcomes.
Start at the mailbox, not the console
The root or owner email address is the master key. Anyone who controls that mailbox can usually trigger a password reset and walk back into the account regardless of what you change inside the console. Securing the console while the previous holder still reads the mailbox achieves very little.
There are two acceptable outcomes. Either the email address itself is handed to you with full control, including its own password and its own second factor, or the account’s email address is changed to one you own. Changing it is the stronger option. If the provider requires confirmation at the old address to make the change, that confirmation has to happen during the handover window while the seller is still cooperating, not afterwards.
Checking the mailbox is really yours
If you are taking over an existing mailbox, treat it as its own account. Change its password, enrol your own second factor, and then open its security settings and look for forwarding rules, filters that move or delete provider mail, app passwords, connected applications and additional recovery addresses. A forwarding rule that quietly copies password reset emails elsewhere is the single most effective back door there is, and it survives a password change. Workspace style mailboxes have more of these surfaces than consumer ones, which is worth knowing if the account sits alongside a Google Workspace tenancy.
Replacing multi-factor authentication
Never keep an inherited second factor. A time based code seed can be enrolled on more than one device, and you have no way to know how many copies exist. Remove every registered factor you did not personally enrol, then add your own.
Order matters. Enrol your factor first, confirm it works by signing out and back in, then remove the old ones. Doing it the other way around risks locking yourself out if the provider requires an active factor at all times. Enrol at least two of your own so that a lost phone is an inconvenience rather than a recovery case. If you want the background on factor types and their trade-offs, multi-factor authentication for cloud accounts covers it.
Recovery paths are back doors with a friendly name
Password resets and MFA resets both run through recovery channels, and those channels are frequently left pointing at the previous holder. Work through every one the provider offers: secondary email, phone number for SMS or voice, printed backup codes, security questions, alternate account contacts for billing and security notifications, and any trusted device list.
Backup codes deserve special attention because they are static. If a set was generated before you arrived, those codes still work. Regenerate them, which invalidates the old set, and store the new set somewhere you control. Likewise, revoke all active sessions once you have finished, so that any browser still signed in elsewhere is kicked out.
Finding every programmatic credential
Now move to machine access. The categories to enumerate are long lived access keys, short lived tokens issued through a role or identity service, service accounts and service principals with their own key material, personal access tokens, deploy keys, and credentials held by installed agents on running machines.
For each credential the console will usually show a creation date and a last used date. Those two fields answer most of your questions. Never used and old means delete without ceremony. Used yesterday means something depends on it and you need to find out what before you touch it. Used two years ago means investigate, because it may belong to a system that still exists but runs rarely.
Be careful with the last used field. It usually reflects activity against the provider’s own interfaces and may not capture every kind of use, and on some platforms it updates on a delay of hours. Treat a blank or stale value as a prompt to look harder rather than as proof of disuse. Where the provider records the source address or the calling service alongside the timestamp, that detail is often enough to identify the consumer without any guesswork.
Rotating keys without breaking what runs
Rotation is where people cause their own outages. The safe pattern is additive: create a new credential, deploy it alongside the old one, confirm through logs that the new credential is being used, then disable the old one, wait, and only then delete it. Disabling before deleting gives you a fast reversal if something fails.
Work through one consumer at a time rather than rotating everything in a single evening. Keep a list of what each credential is for as you go, because that list is the artefact that makes the next rotation easy. Store the new values in a secrets manager rather than in environment files or repository variables, following secrets management practice, so you are not rebuilding the same mess you inherited.
Service accounts and machine identities
Non human identities are the easiest thing to miss because they do not appear in a user list. They are also often over privileged, since they were created quickly to make something work. Review each one against the job it does. A backup agent does not need the ability to create users. A deployment identity does not need billing access.
Where the provider supports it, replace static key material with short lived credentials issued to a workload identity. That removes the rotation problem entirely for those consumers. Not every platform offers this at the same depth, which is one of the practical differences visible when comparing AWS against Azure.
Confirming the previous holder is out
Finish with a verification pass rather than an assumption. Re-list users, roles, keys and sessions and confirm the inventory matches what you expect. Check the audit log for sign in events after your handover time and confirm every one of them is yours, by source address if the log provides it.
Leave a detection in place as well. An alert on console sign in from an unfamiliar location, or on the creation of a new credential, turns a silent return into a notification. Detecting unexpected cloud activity covers how to keep that signal useful instead of noisy.
When rotation is not enough
Sometimes the honest conclusion is that the account cannot be made clean. Signs include credentials you cannot account for, audit logging that was disabled for part of the account’s life, or a provider identity structure that keeps an external party in place. In that situation the right move is to build fresh and migrate.
That is less painful than it sounds, especially for stateless workloads, and it gives you an account whose entire history you can vouch for. Platforms with quick provisioning such as Hetzner make the rebuild cheap, and keeping environments in separate accounts from the start, as argued in separate accounts per environment, means you never have to do this to your whole estate at once.