{"id":374,"date":"2026-10-24T14:30:00","date_gmt":"2026-10-24T14:30:00","guid":{"rendered":"https:\/\/backendside.com\/blog\/?p=374"},"modified":"2026-11-21T11:21:55","modified_gmt":"2026-11-21T11:21:55","slug":"what-happens-when-you-delete-a-file-windows-ntfs","status":"publish","type":"post","link":"https:\/\/backendside.com\/blog\/2026\/10\/24\/what-happens-when-you-delete-a-file-windows-ntfs\/","title":{"rendered":"What Really Happens When You Delete a File on Windows (NTFS, Recycle Bin, MFT)"},"content":{"rendered":"<p class=\"lead\">You press <kbd>Delete<\/kbd>, the file vanishes from Explorer, and it feels final. It almost never is. On a typical Windows NTFS drive, deleting a file is a handful of small bookkeeping edits &mdash; a rename, a flag flipped from 1 to 0, a few bits cleared in a map. The bytes of the file usually stay exactly where they were. This post walks through those mechanics layer by layer: the Recycle Bin, Shift+Delete, the Master File Table, the volume bitmap, cluster reuse and Volume Shadow Copies. If you are in the middle of an emergency right now, read <a href=\"https:\/\/backendside.com\/blog\/2026\/07\/05\/accidentally-deleted-a-file-what-to-do-next\/\">what to do next after deleting a file<\/a> first and come back for the theory later.<\/p>\n<h2>Layer 1: the Recycle Bin is just a rename<\/h2>\n<p>When you delete a file normally in Explorer, nothing is copied anywhere. Every NTFS volume has a hidden, system-protected folder at its root called <code>$Recycle.Bin<\/code>, with one subfolder per user named after that user&rsquo;s security identifier (SID). Windows <strong>moves<\/strong> the file into your SID folder &mdash; and because a move within the same volume is just a rename, it is instant whether the file is 2 KB or 20 GB.<\/p>\n<p>The moved file is split into a matched pair:<\/p>\n<table>\n<thead>\n<tr>\n<th>File<\/th>\n<th>What it holds<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>$R<\/code> + random suffix + original extension (e.g. <code>$RX7K2QD.docx<\/code>)<\/td>\n<td>The actual file contents, untouched. For a folder, the whole folder tree.<\/td>\n<\/tr>\n<tr>\n<td><code>$I<\/code> + the same suffix (e.g. <code>$IX7K2QD.docx<\/code>)<\/td>\n<td>A small metadata record: a format version, the original file size, the deletion time, and the full original path.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The <code>$I<\/code> file is how the Recycle Bin view knows where to put things back when you click <em>Restore<\/em>. Lose the <code>$I<\/code> and the <code>$R<\/code> file is still a perfectly good file &mdash; it has just lost its name and home. You can peek at your own Recycle Bin from PowerShell without opening the hidden folder:<\/p>\n<pre style=\"background:#1e1d1b;color:#eceae6;padding:1rem 1.15rem;border-radius:8px;overflow-x:auto;font-size:.85rem;line-height:1.5;\"><code># List what is currently in the Recycle Bin (shell namespace 10)\n$bin = (New-Object -ComObject Shell.Application).NameSpace(10)\n$bin.Items() | Select-Object Name, Path, Size\n\n# The raw $I \/ $R pairs for drive C: (hidden + system, so -Force)\nGet-ChildItem -Force 'C:$Recycle.Bin' -Recurse -ErrorAction SilentlyContinue |\n  Select-Object FullName, Length, LastWriteTime<\/code><\/pre>\n<p>Only when you <strong>empty<\/strong> the Recycle Bin (or Windows trims it because it hit its size limit) do the <code>$R<\/code> and <code>$I<\/code> files get deleted for real &mdash; and &ldquo;for real&rdquo; turns out to mean the NTFS bookkeeping described below.<\/p>\n<h2>Layer 2: what Shift+Delete actually skips<\/h2>\n<p><kbd>Shift<\/kbd>+<kbd>Delete<\/kbd> does not shred anything. It simply skips Layer 1 and goes straight to the file system deletion. Several other paths skip the Recycle Bin too:<\/p>\n<ul>\n<li><code>del<\/code> in Command Prompt and <code>Remove-Item<\/code> in PowerShell.<\/li>\n<li>Files deleted by most programs through their own code rather than through the shell.<\/li>\n<li>Files on network shares, and on many removable flash drives.<\/li>\n<li>Files larger than the Recycle Bin&rsquo;s configured size for that drive (Windows warns you it will &ldquo;permanently delete&rdquo; them).<\/li>\n<\/ul>\n<p>In every one of these cases the result on disk is the same as emptying the Recycle Bin: the steps in Layer 3 happen, and the data blocks are left behind.<\/p>\n<h2>Layer 3: the MFT record and its in-use flag<\/h2>\n<p>NTFS keeps a database of every file on the volume called the <strong>Master File Table<\/strong> (<code>$MFT<\/code>). Each file and folder gets a fixed-size record &mdash; usually 1 KB &mdash; that starts with the signature <code>FILE<\/code> and contains a list of attributes: the standard timestamps, the file name (often twice, a long name and a short 8.3 name), and the <code>$DATA<\/code> attribute that describes the contents.<\/p>\n<p>For anything but the tiniest files, <code>$DATA<\/code> is <em>non-resident<\/em>: instead of the bytes themselves, it holds <strong>data runs<\/strong> &mdash; a compact list saying &ldquo;the file lives in clusters 1,048,576 to 1,048,831, then 2,201,600 to 2,201,663&rdquo;. Very small files (a few hundred bytes) are <em>resident<\/em>: their content sits inside the MFT record itself.<\/p>\n<p>Here is what NTFS does when a file is deleted, in diagram form:<\/p>\n<pre style=\"background:#1e1d1b;color:#eceae6;padding:1rem 1.15rem;border-radius:8px;overflow-x:auto;font-size:.85rem;line-height:1.5;\"><code>BEFORE                                   AFTER DELETE\n------                                   ------------\nParent folder index ($I30)               Parent folder index\n  report.docx -&gt; MFT #48213                (entry removed)\n\nMFT record #48213                        MFT record #48213\n  flags: IN_USE                            flags: (cleared)\n  $FILE_NAME: report.docx                  $FILE_NAME: report.docx   &lt;- still there\n  $DATA runs: 1048576+256                  $DATA runs: 1048576+256   &lt;- still there\n\n$MFT:$Bitmap  bit 48213 = 1              $MFT:$Bitmap  bit 48213 = 0\n$Bitmap       clusters 1048576..831 = 1  $Bitmap       clusters 1048576..831 = 0\n\nClusters 1048576..1048831: file bytes    Clusters 1048576..1048831: file bytes (unchanged)<\/code><\/pre>\n<p>Four things change: the file&rsquo;s entry is removed from its parent folder&rsquo;s index, the <strong>in-use flag<\/strong> in the record header is cleared, the record is marked free in the MFT&rsquo;s own bitmap, and the clusters it occupied are marked free in the volume bitmap. NTFS also writes the operation to its transaction log (<code>$LogFile<\/code>) and, on most system drives, appends a <em>file delete<\/em> entry to the change journal (<code>$UsnJrnl<\/code>) with the file name and a timestamp. What does <strong>not<\/strong> change: the name, the timestamps, the data runs, and the data itself.<\/p>\n<p>That is why an MFT-based recovery tool can often bring back a deleted file with its original name, size and fragments intact: it scans for records whose in-use flag is clear and follows their data runs.<\/p>\n<p>You can see the basic geometry of your own volume &mdash; cluster size, MFT size, record size &mdash; with a built-in command (run from an elevated prompt):<\/p>\n<pre style=\"background:#1e1d1b;color:#eceae6;padding:1rem 1.15rem;border-radius:8px;overflow-x:auto;font-size:.85rem;line-height:1.5;\"><code>fsutil fsinfo ntfsinfo C:\n:: look for: Bytes Per Cluster, Bytes Per FileRecord Segment, Mft Valid Data Length\n\n:: The change journal: recent create \/ rename \/ delete events\nfsutil usn queryjournal C:\nfsutil usn readjournal C: csv | findstr \/i \"delete\"<\/code><\/pre>\n<div style=\"border:1px solid #c5d3f8;background:linear-gradient(135deg,#eef2fd 0%,#ffffff 72%);border-radius:14px;padding:1.5rem 1.65rem;margin:2rem 0;\">\n<div style=\"font-size:.7rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase;color:#2d5be3;margin-bottom:.55rem;\">&#128295; BackendSide Tool<\/div>\n<h4 style=\"margin:0 0 .45rem;font-size:1.15rem;color:#1a1916;font-weight:700;\">DeepRecoveryDesk &mdash; Reads the MFT So You Don&rsquo;t Have To<\/h4>\n<p style=\"margin:0 0 1.05rem;color:#3d3c38;font-size:.92rem;line-height:1.65;\"><strong>DeepRecoveryDesk<\/strong> reconstructs deleted files straight from the file system: it reads the NTFS master file table, cross-references the change journal to surface the names, times and folders of recently deleted files, and restores items emptied from the Recycle Bin without administrator rights. Source drives are opened <strong>strictly read-only<\/strong>, and every recovered file is verified with a SHA-256 checksum.<\/p>\n<p>  <a href=\"https:\/\/backendside.com\/deeprecoverydesk.php\" style=\"display:inline-flex;align-items:center;gap:.4rem;background:#2d5be3;color:#ffffff;font-weight:600;font-size:.85rem;padding:.6rem 1.2rem;border-radius:6px;text-decoration:none;\">Explore DeepRecoveryDesk &rarr;<\/a>\n<\/div>\n<h2>Layer 4: $Bitmap and the start of the countdown<\/h2>\n<p>The volume bitmap (<code>$Bitmap<\/code>, one of the hidden NTFS metadata files) has one bit per cluster: 1 means in use, 0 means free. Once your file&rsquo;s clusters flip to 0, they are fair game for the next write. Nothing erases them; they are simply <em>available<\/em>.<\/p>\n<p>This is the single most important idea in data recovery. Deletion starts a countdown, and every write to the drive is a chance for that countdown to end. On a system drive, writes never really stop: browser caches, Windows Update, log files, search indexing, app telemetry, the page file. A freed cluster on a busy C: drive can be reused within minutes; on an idle external archive drive it might survive for years.<\/p>\n<p>Reuse is also usually <strong>partial<\/strong>. A new 40 KB file might land in the middle of your old 50 MB video, leaving the rest intact. That is why recovery results often come back as &ldquo;partly overwritten&rdquo;: the MFT record still promises clusters that now belong, in part, to someone else.<\/p>\n<h2>Layer 5: MFT record reuse<\/h2>\n<p>The MFT record itself is also marked free, so NTFS will eventually hand that record number to a brand-new file. When that happens, the old name and data runs are overwritten in one go, and MFT-based recovery for that file is over &mdash; even if the data clusters are still physically intact. At that point two weaker trails remain:<\/p>\n<ul>\n<li><strong>The change journal<\/strong> may still remember that <code>report.docx<\/code> existed and when it was deleted &mdash; useful for knowing what you lost, but it does not say where the data lived.<\/li>\n<li><strong>Signature carving<\/strong> ignores metadata entirely and scans free clusters for known file headers (a JPEG starts with <code>FF D8 FF<\/code>, a ZIP-based Office file with <code>PK<\/code>, and so on), then reconstructs files by structure. Carved files lose their names and folders, and fragmented files are hard to carve.<\/li>\n<\/ul>\n<p>For a comparison of how this differs on FAT32 and exFAT &mdash; where the file allocation table is zeroed out and fragmented files are much harder to rebuild &mdash; see <a href=\"https:\/\/backendside.com\/blog\/2026\/06\/26\/recovering-deleted-files-on-windows-ntfs-fat32-exfat-and-what-actually-survives\/\">recovering deleted files on NTFS, FAT32 and exFAT, and what actually survives<\/a>.<\/p>\n<div style=\"border:1px solid #c5d3f8;background:linear-gradient(135deg,#eef2fd 0%,#ffffff 72%);border-radius:14px;padding:1.5rem 1.65rem;margin:2rem 0;\">\n<div style=\"font-size:.7rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase;color:#2d5be3;margin-bottom:.55rem;\">&#128295; BackendSide Tool<\/div>\n<h4 style=\"margin:0 0 .45rem;font-size:1.15rem;color:#1a1916;font-weight:700;\">DeepRecoveryDesk &mdash; Honest About Reused Clusters<\/h4>\n<p style=\"margin:0 0 1.05rem;color:#3d3c38;font-size:.92rem;line-height:1.65;\">Because cluster reuse is the thing that actually destroys deleted data, <strong>DeepRecoveryDesk<\/strong> checks each deleted file&rsquo;s storage against the drive&rsquo;s own record of what is in use. Files whose space has since been taken are marked <em>Overwritten<\/em> or <em>Partly overwritten<\/em> and their confidence drops, so the results never promise data that is already gone. Its Deep scan reads the file system&rsquo;s free-space map and carves unallocated space only &mdash; live files are never listed as deleted.<\/p>\n<p>  <a href=\"https:\/\/backendside.com\/deeprecoverydesk.php\" style=\"display:inline-flex;align-items:center;gap:.4rem;background:#2d5be3;color:#ffffff;font-weight:600;font-size:.85rem;padding:.6rem 1.2rem;border-radius:6px;text-decoration:none;\">Explore DeepRecoveryDesk &rarr;<\/a>\n<\/div>\n<h2>Layer 6: Volume Shadow Copies and Previous Versions<\/h2>\n<p>There is one more place old data can hide. The <strong>Volume Shadow Copy Service<\/strong> (VSS) creates point-in-time snapshots of a volume &mdash; for System Restore points, some backup tools, and the <em>Previous Versions<\/em> tab in a file&rsquo;s or folder&rsquo;s Properties. VSS is copy-on-write at the block level: after a snapshot is taken, whenever a block is about to be overwritten, its old contents are copied into a hidden diff area first. A deleted file that existed when the snapshot was taken can therefore be retrieved from the snapshot even after its clusters have been reused on the live volume.<\/p>\n<pre style=\"background:#1e1d1b;color:#eceae6;padding:1rem 1.15rem;border-radius:8px;overflow-x:auto;font-size:.85rem;line-height:1.5;\"><code># Elevated: list existing shadow copies on this PC\nvssadmin list shadows\n\n# Same information from PowerShell\nGet-CimInstance Win32_ShadowCopy |\n  Select-Object VolumeName, InstallDate, DeviceObject<\/code><\/pre>\n<p>Two caveats. On client editions of Windows, shadow copies only exist if System Restore (or a backup tool) is creating them for that drive, and many systems have it limited to C: or switched off. And the diff area has a size cap, so older snapshots are discarded as new ones arrive. If <code>vssadmin<\/code> lists nothing, this escape hatch is closed. Right-click the parent folder &rarr; <em>Properties<\/em> &rarr; <em>Previous versions<\/em> is the friendly way to check.<\/p>\n<h2>Putting the layers together<\/h2>\n<table>\n<thead>\n<tr>\n<th>What you did<\/th>\n<th>Where the data is<\/th>\n<th>How it comes back<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Delete (Recycle Bin not emptied)<\/td>\n<td>Intact, renamed to <code>$R&hellip;<\/code><\/td>\n<td>Restore from the Recycle Bin<\/td>\n<\/tr>\n<tr>\n<td>Emptied the bin \/ Shift+Delete<\/td>\n<td>Clusters freed, MFT record flagged unused<\/td>\n<td>MFT-based recovery: name, folder, fragments<\/td>\n<\/tr>\n<tr>\n<td>Record reused, clusters not<\/td>\n<td>Data present, metadata gone<\/td>\n<td>Signature carving (no names); journal shows what it was<\/td>\n<\/tr>\n<tr>\n<td>Clusters reused<\/td>\n<td>Overwritten, fully or partly<\/td>\n<td>Only a shadow copy or backup taken earlier<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>One case is deliberately missing from this table: solid-state drives. On an SSD, Windows tells the drive which blocks were freed, and the drive may wipe them on its own schedule &mdash; that changes the whole picture and deserves its own article.<\/p>\n<h2>Why recovery tools must be read-only<\/h2>\n<p>All of the above leads to one hard engineering rule for recovery software: never write to the source drive. Installing a recovery tool onto the drive you are recovering from, saving recovered files back to it, or letting a tool &ldquo;fix&rdquo; the file system first can each overwrite exactly the clusters you are trying to save. A careful tool opens the volume read-only, refuses to recover onto the same drive, and verifies what it writes elsewhere.<\/p>\n<p>That is how <strong>DeepRecoveryDesk<\/strong> is built: it reads the MFT and change journal directly, opens source drives strictly read-only, refuses to recover back onto the source drive, and lets you preview each result &mdash; a text snippet, an image thumbnail or a hex dump &mdash; before you recover it. For a drive that is starting to fail, it can copy the drive sector by sector into a disk image once and then scan and recover from the copy. It is still a pre-1.0 product, so treat it as a careful first-line tool rather than a forensic lab.<\/p>\n<div style=\"border:1px solid #c5d3f8;background:linear-gradient(135deg,#eef2fd 0%,#ffffff 72%);border-radius:14px;padding:1.5rem 1.65rem;margin:2rem 0;\">\n<div style=\"font-size:.7rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase;color:#2d5be3;margin-bottom:.55rem;\">&#128295; BackendSide Tool<\/div>\n<h4 style=\"margin:0 0 .45rem;font-size:1.15rem;color:#1a1916;font-weight:700;\">DeepRecoveryDesk &mdash; Reads the MFT So You Don&rsquo;t Have To<\/h4>\n<p style=\"margin:0 0 1.05rem;color:#3d3c38;font-size:.92rem;line-height:1.65;\"><strong>DeepRecoveryDesk<\/strong> reconstructs deleted files straight from the file system: it reads the NTFS master file table, cross-references the change journal to surface the names, times and folders of recently deleted files, and restores items emptied from the Recycle Bin without administrator rights. Source drives are opened <strong>strictly read-only<\/strong>, and every recovered file is verified with a SHA-256 checksum.<\/p>\n<p>  <a href=\"https:\/\/backendside.com\/deeprecoverydesk.php\" style=\"display:inline-flex;align-items:center;gap:.4rem;background:#2d5be3;color:#ffffff;font-weight:600;font-size:.85rem;padding:.6rem 1.2rem;border-radius:6px;text-decoration:none;\">Explore DeepRecoveryDesk &rarr;<\/a>\n<\/div>\n<h2>Key takeaways<\/h2>\n<ul>\n<li>A normal Delete is a <strong>rename into <code>$Recycle.Bin<\/code><\/strong>: the <code>$R<\/code> file is your data, the <code>$I<\/code> file remembers its original path, size and deletion time.<\/li>\n<li><strong>Shift+Delete<\/strong>, <code>del<\/code>, <code>Remove-Item<\/code> and most program deletions skip the bin but do <strong>not<\/strong> erase data.<\/li>\n<li>An NTFS delete clears the MFT record&rsquo;s <strong>in-use flag<\/strong>, removes the folder index entry, and frees clusters in <strong><code>$Bitmap<\/code><\/strong>. Name, timestamps and data runs stay put.<\/li>\n<li>Data is lost when <strong>clusters are reused<\/strong> (often partly); metadata is lost when the <strong>MFT record is reused<\/strong>. Carving and the change journal are the fallbacks.<\/li>\n<li><strong>Shadow copies<\/strong> can hold pre-deletion blocks if System Restore or backups were creating them &mdash; check with <code>vssadmin list shadows<\/code>.<\/li>\n<li>Recovery only works if the source drive stays untouched: stop writing to it, and use a <strong>read-only<\/strong> tool such as DeepRecoveryDesk that recovers to a different drive.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Pressing Delete on Windows almost never erases anything. A step-by-step look at the mechanics underneath: the Recycle Bin and its paired $I and $R files, what Shift+Delete really skips, the MFT record flag that flips, the $Bitmap that frees your clusters, and why shadow copies sometimes still hold the old data.<\/p>\n","protected":false},"author":1,"featured_media":403,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8,2],"tags":[38,62,64,61,63],"class_list":["post-374","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tutorials","category-windows","tag-data-recovery","tag-deeprecoverydesk","tag-mft","tag-ntfs","tag-recycle-bin"],"_links":{"self":[{"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/posts\/374","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/comments?post=374"}],"version-history":[{"count":1,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/posts\/374\/revisions"}],"predecessor-version":[{"id":404,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/posts\/374\/revisions\/404"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/media\/403"}],"wp:attachment":[{"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/media?parent=374"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/categories?post=374"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/backendside.com\/blog\/wp-json\/wp\/v2\/tags?post=374"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}