How to Back Up and Restore a Website in cPanel
Create website, database and mail backups in cPanel and test a restore before you rely on them.

Quick answer
Use cPanel’s available backup options to preserve the files and databases your site actually needs. Keep a separate copy, record the backup time and test the supported restore workflow on an isolated copy of the website.
Rehearse a restore from two separate backup components
Imagine a site whose media files are managed under a domain’s document root and whose pages are stored in MariaDB. An owner downloads a file archive and database export made at approximately the same point. On a separate account or isolated staging location, the owner creates a fresh database and user, restores the export using the hosting provider’s documented workflow, and configures the application to use the temporary database. The owner then restores the files to a separate supported root. The test confirms the site can read page records, find a referenced image and process a harmless test upload. It also checks wherever the site expects its alternate HTTPS hostname, media base and application cache to be configured.
Check which of these steps are possible from your plan before a real outage. Some provider-managed full-account restore workflows require support or WHM access. Partial restoration can be more appropriate when you only need one schema or file directory. Keep the database version and exported output limits in the notes. Avoid restoring an archive into a web-accessible location while it is unpacked if the archive contains configuration or customer information. Use the provider’s expected ownership and paths instead of applying arbitrary permissions. Measure how long it took to regain useful behavior after loading the archive. Also identify how much recent data the archive excluded, such as edits made after the export. Those numbers help decide whether to back up more often or improve recovery procedures.
Map the data before downloading
A PHP site uses uploaded media, a database and a mailbox.
Identify the actual document root, persistent folders, databases, scheduled jobs and relevant mail or DNS settings. Note components hosted elsewhere. Start with conditions you can readily repeat. Ask if your normal day includes a meaningful variation, such as a busy period, a second account or input from a different source. Select the variation based on your real use instead of trying every theoretical case.
Someone archives public files but leaves out the database that stores user content. Record whether you found a recurring failure, a one-time event or an unresolved observation. The three have different implications. A repeating mismatch is easier to verify and to pass along for repair. A one-time interruption can still matter, but document the context and look for a separate observation before committing to an explanation.
Compare the inventory against a working copy and explicitly label external data dependencies. A simple check for the result usually beats a complicated proxy. If a reading looks surprising, return to the user-visible outcome and trace it back to the earliest relevant event you can observe. Comparing that observation to the expected rule may show exactly what additional information to collect.
If two domains share files or a database, document how their state will be restored together. Use a representative size or repetition count when it affects the result. If a small test and a normal-sized workload behave differently, include both in the handoff so the earlier test can be understood in context.
Choose full or partial backup
Use this case to review the plan. The hosting plan offers Backup Wizard and a full-account archive.
Check which restoration options the provider permits. A full-account archive can help a provider move the account, while partial restore may be available to an account holder. Write down who owns the setting, file, service or decision before considering the trial finished. In a personal setup that may simply mean keeping the needed information somewhere you can find it later. In a shared setup it may determine whether the next person is able to continue during an interruption. Give that person enough context to determine if the result still applies.
Failure that matters: The team obtains a full backup and assumes there is a one-click self-service full restore.
Read current control-panel guidance and ask who can restore each component. A successful check has a concrete observable result. Confirm it from the normal user path, then put the test input and the observation in your notes. If cleanup is needed, remove test artifacts carefully and retain the benign evidence needed to repeat the test later.
Keep targeted database and file exports if a full restore would be slower than the recovery goal. Check any agreement about when to rerun the trial. An annual review can miss changes that happen at a specific release or after access is revoked. Conversely, some checks make sense on a fixed calendar because no individual event will remind you to try them. Choose the trigger that fits the use case and record a known starting point.
Preserve current database state
Try it when you need to: The site uses a SQL database with active transactions.
Use the database’s supported export workflow and consider consistency with content changes or uploads. Record the cut-off time.
Establish the expected result before starting. A useful way to make this concrete is to describe the one thing you plan to observe and the condition under which it should hold. Save a baseline using the same input or conditions you will use after the change. If another person helps, have them record the expected result independently. That can surface a difference in interpretation before you spend time debugging an apparent failure.
An easy mistake to miss: A database dump and media archive capture different states during a busy publishing window.
Restore the files and database to staging and spot-check rows against their associated files. Preserve the comparison in a form you can come back to: write down the input, what you expected and what you actually saw. In a decision with several options, keep one record per option rather than changing the definition of success for each trial.
For transactional sites, coordinate a final copy or a consistent cut-over window as appropriate. Think about whether this follow-up calls for revising the original rule or handling a separate case. If it is separate, keep the original test available and check that both cases still succeed. This is also useful when you need to explain why something that looked fine in a demonstration behaves differently in ordinary use.
Keep a copy outside the account
The only visible backup is stored under the hosting home directory. This is a good place to watch where the result starts to differ from what you expect. Note the entry conditions and any settings or data that you have assumed. Take an initial reading, then do the work with those same conditions recorded. Avoid resetting everything at the first sign of trouble. A change that accidentally hides the symptom gives you less information about what caused it.
Download backup archives to approved storage with independent access. Restrict/archive credentials and confirm there is enough space for the export.
Inspect this failure: A hosting account issue affects both the live files and the only recovery copy. Make the first follow-up test small enough to repeat without changing unrelated parts of the setup. Start at the first boundary you can observe, then check the next one only if the initial result was right. Write down the observations in order. A later symptom can look like the root problem if you check the later step first and do not have an earlier reading.
Open a copy safely and verify checksums or archive contents before clearing any temporary host files. When the check is successful, repeat the ordinary action from its normal starting point. This catches results that only worked because the original test left a session, a temporary setting or a sample file in place. If somebody else follows the directions later, their starting conditions might be different.
Review retention and access on the backup destination as part of the ownership handoff.
Restore away from production
A new host can be used to rehearse recovery.
Begin with a simple case where you can tell if things went wrong even before looking at any reports. Keep a copy of the starting inputs and confirm the result that ought to follow from them. Ask what the user will see and what the underlying system ought to do. Those are worth checking separately when a screen, message or summary can still look correct even though a change did not reach the place you intended.
Create an isolated application root and database, then restore using the provider-approved workflow. Keep outgoing messages and live integrations separate.
A copied site contacts real users because its original mail configuration was restored unchanged. Include this possibility when you define a failure. Try a known good case beside the suspected one. If both fail in the same way, examine what they share. If only the particular case fails, save the difference that makes it a useful test.
How to verify: Test ordinary pages and approved writes with synthetic records and safe endpoints.
Depend on separate staging credentials and note settings that are supplied outside the archive. On the next pass, use a second representative input or condition to make sure the first result still applies. A narrow test can be decisive if it measures the thing you need. A wider sample is useful when your real work includes several distinct patterns and one result cannot stand for all of them.
Check file and app permissions
Restoring files produces a working home page but broken uploads. Before putting time or money into this step, agree on a concrete criterion. Treat whatever is essential to complete the job as a mandatory requirement. Keep convenience, speed and ease of handoff in a separate part of your notes. This helps you avoid promoting something that looks easier in a trial but cannot complete a critical part of the task.
Start here. Confirm ownership and the permissions expected by the host and application. Check write locations and custom runtime settings.
An operator grants broad write permissions while the actual problem is an incorrect path or owner. Think through how a customer or colleague would discover this error. A clear, visible failure is easier to resolve than a result that looks successful and leaves a problem for the next person. If it would be hard to notice, add one direct inspection that examines the outcome itself. Record evidence for the result instead of relying entirely on a successful status label.
Confirm the result. Use a safe upload or save operation and identify the precise directory or permission that failed. Work through this step before expanding the change. One realistic example is enough to reveal a category of failures that an ideal example misses. A trial is also a useful time to learn what to do when the result is ambiguous, especially if different people would have to resolve disagreement.
Record application restart and cache requirements where the host manages the process. Capture the decision and the reason in a short note so it can be revisited if the workload, policy or software changes.
Measure recovery actually achieved
Example situation. A restore completed successfully according to the panel.
Check important flows, not only files or database row counts. Compare the last recoverable activity with what users expect. Give the test enough room to show the original problem. Use the same entry point that someone with the issue would use. If several variables change between attempts, note which ones cannot be held constant and avoid assigning a cause yet. You can make a smaller experiment after getting that first picture.
The archive is intact but misses a recent form or a recent schema change. It helps to document the specific contrast as soon as you see it. Save an innocuous screenshot, a small sample or a short time record if appropriate, with identifying details removed when they are unnecessary. The next person will need a result that can be interpreted without guessing what happened immediately before you captured it.
Inspect the outcome. Open a few representative records, media, admin paths and background jobs under test conditions. If you need to hand this to support or a maintainer, include the expected outcome, the first unexpected observation and the last known working state.
Measure both operational recovery time and the gap between the backup time and recent activity. Write down whether the follow-up confirms your original explanation or exposes another factor. Confirmed evidence supports a specific change. If the behavior still varies without a known reason, retain the last working settings and focus the next test on that variation.
Write a recovery sheet
A second maintainer should be able to restore the site when the owner is unavailable. Decide what should stay intact while you try the change. For a small trial this might be the original input, a visible result another person already depends on, or access from a second supported device. Keep an appropriate copy or note of the earlier state. Tests that are easy to reverse make it possible to learn even when the first idea is wrong.
Document archive locations, lookup names, approved restore order and support contacts. Keep secret material in the approved store.
Watch for this: The steps mention a database password but nobody knows who can recover it. Consider the exact point where you would stop and revert. If the issue appears, reproduce it without repeating a consequential action unnecessarily. A disposable example or read-only observation can give you the needed evidence. In a shared environment, tell others handling the test what state you expect to see before the next step.
Ask another authorized person to restore a sample without the live owner’s workspace. Verify the ordinary case that should have remained intact as well as the intended improvement. If one passes and the other fails, keep both observations and examine the relationship between them.
Refresh the notes when changing host, release system or data storage. Use the result to write a one-sentence acceptance condition. Make it specific enough that another person would know which setup to use and when to stop.
A short verification checklist
| What to check | How to tell |
|---|---|
| Map the data before downloading | Compare the inventory against a working copy and explicitly label external data dependencies. |
| Choose full or partial backup | Read current control-panel guidance and ask who can restore each component. |
| Preserve current database state | Restore the files and database to staging and spot-check rows against their associated files. |
| Keep a copy outside the account | Open a copy safely and verify checksums or archive contents before clearing any temporary host files. |
## Test exactly one controlled restore
Pick one published item with a known URL and image, plus a synthetic form or editable record. Restore the relevant archive and database in staging. Open the item, test a new write in staging and verify an associated media file. Record the archive dates and which data would be absent if they were the only copies. If support must perform a full restore, confirm the process and expected turnaround from the provider. Store separate access to the instructions and backups and keep application secrets outside a public recovery checklist.
Related reading
Reference documentation explains the relevant standards or workflow. Try the related FixHubLab resource for a practical next step. Use the FixHubLab blog to find the rest of the guide series.
