Same 1 GB, Yet a Photo Folder Copies Slower Than a Single Video — Why?

Even with the same total size of 1 GB, copy time changes with the number of times files must be opened, created, and closed. This article explains how file count and waiting time affect copying and how to compare ZIP archives and concurrent copying under equivalent conditions.

In the diagram a solid line marks a relation that always holds and a dashed line marks a conditional one (the conditions are given per relation on the detail page). The full list of relations (11 in total, with evidence and certainty) and the definitions of the main concepts are collected on the knowledge map detail page (in Japanese). Data: JSON-LD / Turtle

Issue / Question

A 1 GB video copied quickly, but a photo folder totaling 1 GB took much longer. Why does the displayed transfer rate fall when copying many small files, even when an SSD or high-speed LAN is used?

This article answers two questions: “Why does copy time differ even when the total size is the same?” and “How can I determine whether combining files into a ZIP archive or copying them concurrently will help in my environment?” It does not diagnose slowness or failure merely from the fact that the files are photos. Instead, it compares the number of files and the time required before those files are usable.

Environment

This article is intended for general users copying ordinary, locally available files such as photos and documents from Windows 11 to an external drive or a NAS accessed through an SMB share. A NAS is a storage device used over a network, and SMB is the communication protocol commonly used for Windows file sharing.

The examples use File Explorer, Compress-Archive in Windows PowerShell 5.1 or later, and the robocopy utility included with Windows. To run the command examples, you need read permission for the source and permission to create and write files in the experimental folder and destination. These procedures do not use administrator privileges to bypass access controls.[S7: Compress-Archive] [S9: robocopy]

Extracting a ZIP archive on the NAS itself is possible only when that NAS provides the feature and you have permission to use it. Server-oriented SMB documentation is cited to explain the underlying mechanism; it does not imply that every NAS has the same settings or features.

This explanation is based on official documentation checked on September 17, 2026. The numerical examples below are calculations based on stated assumptions, and the operations are procedures readers can use to test their own environments. They are not measurements from a particular Windows PC, SSD, or NAS. Downloading cloud files that are available only online and designing complete backups are outside the scope of this article.

Answer / Resolution

Total byte count is not the only factor that determines copy time. Repeating file creation, management, and completion work for every file increases the time spent on operations other than transferring content. With an SMB share, time spent waiting for the remote system to process requests and return responses also matters. Combining files in a ZIP archive or using robocopy concurrency may help, but neither method is guaranteed to be faster.[S1: Slow SMB files transfer speed]

First record both the total size and the number of files, and compare the alternatives over the same path and to the same final destination. For ZIP, compare the combined time required to create, transfer, and, when necessary, extract the archive. For concurrent copying, use the same data and options and change only the concurrency level. Verify speed and successful copying separately.

Definition

Copying a file involves more than writing its contents somewhere else. The destination file must be created, and necessary attributes, timestamps, and other information must be set. In this article, the processing and waiting required to handle each file is called “additional time per file,” distinguishing it from the time spent transferring file contents.[S2: CreateFileW function]

“Small files” is not another name for photos. A few large photos and tens of thousands of small images present different conditions. The comparison concerns both the total number of content bytes—the folder’s “Size”—and the number of files, rather than matching only “Size on disk.”

In a move, one large box and ten thousand individually addressed parcels may have the same total weight but require very different amounts of work. In the same way, “transport 1 GB” and “process 10,000 files” are different jobs.

flowchart TB
    accTitle: Different file counts with the same total size
    accDescr: Even when both data sets total 1 GB, one file and many files require different numbers of file-management operations.
    A["A total of 1 GB of data"] --> B["One large file"]
    A --> C["10,000 small files"]
    B --> D["Few per-file operations"]
    C --> E["Repeat per-file operations"]

Figure 1: Equal byte counts do not imply equal file counts.

For the explanatory data used below, 1 GB means 1,000,000,000 bytes and 100 KB means 100,000 bytes. Record the actual byte counts in comparisons instead of relying on rounded values displayed by Windows or other tools.

Purpose

The purpose of copying is to make the required set of files usable at the intended destination. A high MB/s value in the transfer window does not necessarily achieve that purpose sooner if creating or extracting a ZIP archive takes a long time.

ZIP combines the files being transferred, while concurrent copying overlaps the waits incurred while multiple files are processed. Concurrency lets one transfer make progress while another is waiting; it does not add delay. Neither method makes the network link or disk itself faster, and each is suited to different conditions.[S1: Slow SMB files transfer speed] [S4: Performance Tuning for SMB File Servers]

flowchart TB
    accTitle: Goal when selecting a copy method
    accDescr: Put the same set of files in the intended location, verify their contents, and compare the time until they can be used.
    A["Place the same files at the destination"] --> B["Complete the copy"]
    B --> C["Verify the count and contents"]
    C --> D["Compare time until usable"]

Figure 2: The goal of selecting a method is to make the same set of files available correctly.

One large file serves as a control for observing the effect of file count. Because its structure differs from that of 10,000 small files, it is not a practical substitute for them. When choosing an actual method, the objective is to place the original individual files at the same final destination.

Structure

Contents, management information, and copy path

Copying includes opening the source, creating the destination file, reading and writing the contents, setting necessary information, and closing the file. Opening a file in Windows also involves requested access and a sharing mode that determines whether other processes can open it concurrently.[S2: CreateFileW function]

Information used to manage a file, such as its name, size, and timestamps, is metadata. NTFS records management information for every file in structures including the Master File Table (MFT). Copying is therefore not simply a matter of writing a photo’s pixel data.[S3: Master File Table]

flowchart TB
    accTitle: Work involved in copying one file
    accDescr: For each file, copying requires opening the source, creating the destination, transferring contents, managing information, and closing the file.
    A["Open the source"] --> B["Create the destination file"]
    B --> C["Read and write the contents"]
    C --> D["Set information and close"]
    D -.-> E["Repeat for the next file"]

Figure 3: Conceptual flow; actual ordering and concurrency depend on the copy method and file system.

File-management work remains even when an SSD is used. Do not estimate the time for 10,000 files solely from a large-file sequential transfer rate, and do not classify all small-file copying as random I/O. Consider content placement and per-file work separately.[S3: Master File Table] [S1: Slow SMB files transfer speed]

Mechanism

The mechanisms that can produce different times for the same total size can be divided into three areas: waiting for responses, combining files into a ZIP archive, and the location where extraction occurs.

Bandwidth and response waiting are different characteristics of a NAS

With an SMB share, a PC can request a file operation, wait while the remote file system processes it, and then wait for the response to return. When many small files are copied sequentially, file-creation work can take more time than sending their contents, leaving some network bandwidth unused.[S1: Slow SMB files transfer speed]

flowchart TB
    accTitle: File operations over a network
    accDescr: A request from the PC crosses the network, is processed by the remote file system, and returns a response to the PC.
    A["PC requests a file operation"] --> B["Request crosses the network"]
    B --> C["Remote system processes the file"]
    C --> D["Response returns to the PC"]

Figure 4: Carrying a large amount at once and responding quickly to each operation are different capabilities.

Bandwidth is analogous to the number of lanes on a road, while latency is analogous to the time before a response arrives. Antivirus inspection can also affect the processing time for each file.[S1: Slow SMB files transfer speed]

This does not mean that every file necessarily causes a fixed number of network exchanges. SMB can combine multiple operation requests, and caching and concurrency alter how waits occur. Do not assume that a home LAN and a remote shared folder provide equivalent conditions.[S5: Sending Compounded Requests] [S8: File Caching]

Evaluate ZIP compression and aggregation separately

A ZIP archive can compress data and combine multiple files in one container. Because JPEG data is already compressed, putting JPEG files in a ZIP archive might not reduce their size very much. It can nevertheless reduce the number of files transferred from 10,000 to one.[S6: Zip and unzip files]

flowchart TB
    accTitle: Two roles of ZIP
    accDescr: Combining files changes the number of transferred files, while compression changes the number of transferred bytes; these are separate effects.
    A["Combine photos in a ZIP archive"] --> B["Transfer one file"]
    A --> C["Size change depends on contents"]

Figure 5: Even when compression is slight, ZIP can reduce the number of files transferred.

If the photos must ultimately be used as ordinary files in a folder, compare the following total:

Time required via ZIP = ZIP creation + ZIP transfer + extraction

Creating a ZIP archive reads each small file, and extraction recreates each small file at the extraction destination. The work is not eliminated; the method changes where the work occurs and how the files are transported. When the processing before and after transfer is substantial, not combining the files may be faster.[S1: Slow SMB files transfer speed]

Distinguish which device performs extraction

If a ZIP archive is sent to the recipient’s PC and extracted to that PC’s local drive, the individual small files do not have to be created over the network. Microsoft likewise describes extracting an archive on the destination system rather than extracting it remotely.[S1: Slow SMB files transfer speed]

flowchart TB
    accTitle: Extraction on the destination versus extraction from a PC to a share
    accDescr: Distinguish internal extraction by the destination from a PC writing each extracted file to a shared destination.
    A["Send ZIP to the destination"] --> B["Destination extracts it internally"]
    C["Extract with an application on the PC"] --> D["Send each small file to the share"]

Figure 6: A ZIP file being stored on the NAS does not mean extraction also occurs inside the NAS.

If you open a ZIP archive stored on the NAS in File Explorer on the PC and select the same shared folder as the extraction destination, the PC writes the extracted small files back to the NAS. That route again involves detailed network operations and is distinct from internal extraction performed through a feature of the NAS itself.

If the NAS cannot extract the archive itself, measure the complete route that is actually available. Extracting on the NAS and extracting locally on the PC produce different final destinations, so their times cannot be compared directly as though they performed the same job.

Examples

This section provides an illustrative calculation and comparison data generated by the procedure. Neither represents a measured speed from a particular computer.

Simplified calculation for 1 GB and 10,000 files

The following conceptual model assumes that operations occur sequentially without overlap. It is not the exact formula used by Windows.

Copy time ≒ Total bytes ÷ content transfer rate
           + Number of files × additional time per file

For illustration, assume a content transfer rate of 100 MB/s and an additional time of 2 ms per file. Because 1 GB equals 1,000 MB here, the content transfer takes 10 seconds. The per-file addition is 0.002 seconds for one file and 20 seconds for 10,000 files, giving the latter an illustrative total of approximately 30 seconds.

flowchart TB
    accTitle: Divide copy time into two components
    accDescr: Separate transfer time determined by total size from additional time that accumulates with the number of files.
    A["Time determined by total size"] --> C["Total copy time"]
    B["Additional time determined by file count"] --> C

Figure 7: As file count increases, time can depend on more than the amount of data.

These values are calculated from assumptions. Concurrency, caches, CPU limits, and storage constraints are omitted, so the calculation does not predict that an actual device will take 30 seconds.

Large file, small files, and an uncompressed ZIP archive

Basis of the comparison data

You can observe trends with your own videos and photos, but those files differ in contents and compressibility. The following procedure writes the same byte sequence to one large file and a set of smaller files, and then creates an uncompressed ZIP archive from the smaller files.

flowchart TB
    accTitle: Three forms of comparison data
    accDescr: Create one large file and many small files with the same total content, then create an uncompressed ZIP archive from the small files.
    A["Prepare the same total of 1 GB"] --> B["One 1 GB file"]
    A --> C["10,000 files of 100 KB"]
    C --> D["Put the same contents in an uncompressed ZIP"]

Figure 8: With an uncompressed ZIP, observe aggregation separately from any change in compressed size.

A and B have the same total content, but the size of the ZIP file in C is not exactly 1,000,000,000 bytes. The .bin files created from pseudorandom bytes cannot be opened as actual photos or videos, cannot test photo quality, and do not reproduce the behavior of applications that process real media files.

Procedure

Begin with a comparison in File Explorer. Compare robocopy concurrency levels only when necessary. Use experimental data rather than important photos or documents, and do not confuse copying with moving.

Do not change protective features, SMB signing, synchronization settings, or similar controls. If write permission or NAS operation is managed, do not bypass those controls; consult the responsible administrator.[S10: SMB signing overview]

Create experimental files with the same total size

Use Windows PowerShell 5.1 or later and confirm that the temporary folder is on a local drive. A and B use approximately 2 GB together, and adding the ZIP archive uses approximately 3 GB. Ensure that the source has at least 5 GB of available space and that the destination has enough space for all copy and extraction trials. Run the PowerShell examples consecutively in the same PowerShell session.

flowchart TB
    accTitle: Create two data sets from the same byte sequences
    accDescr: Add each generated block of 100000 pseudorandom bytes to the large file and save the same block as a separate small file.
    A["Generate 100000 bytes"] --> B["Append to one.bin"]
    A --> C["Save as a separate part file"]
    B --> D["Repeat 10,000 times"]
    C --> D

Figure 9: Writing the same generated bytes to both data sets makes their total content sizes equal.

1. Confirm that you will work in a new experimental folder and will not use existing data.

   The code creates a uniquely named copylab folder. Record the displayed location. The procedure does not silently resume an interrupted run; if an error occurs, exclude the data from that run from the comparison.

2. Run the following code to create one large file and a set of small files.

   $ErrorActionPreference = 'Stop'
   $lab = Join-Path ([System.IO.Path]::GetTempPath()) ('copylab-' + [guid]::NewGuid().ToString('N'))
   $drive = New-Object System.IO.DriveInfo ([System.IO.Path]::GetPathRoot($lab))
   if ($drive.AvailableFreeSpace -lt 5GB) {
       throw 'Ensure that the experimental drive has at least 5 GB of available space.'
   }
   $largeDir = Join-Path $lab 'large'
   $smallDir = Join-Path $lab 'small'
   [System.IO.Directory]::CreateDirectory($largeDir) | Out-Null
   [System.IO.Directory]::CreateDirectory($smallDir) | Out-Null
   Write-Host "Created at: $lab"
       
   $fileCount = 10000
   $buffer = New-Object byte[] 100000
   $random = New-Object System.Random 20260905
   $large = [System.IO.File]::Open(
       (Join-Path $largeDir 'one.bin'),
       [System.IO.FileMode]::CreateNew,
       [System.IO.FileAccess]::Write,
       [System.IO.FileShare]::None
   )
   try {
       for ($i = 0; $i -lt $fileCount; $i++) {
           $random.NextBytes($buffer)
           $name = 'part-{0:D5}.bin' -f $i
           [System.IO.File]::WriteAllBytes((Join-Path $smallDir $name), $buffer)
           $large.Write($buffer, 0, $buffer.Length)
       }
   }
   finally {
       $large.Dispose()
   }
   Write-Host "Preparation complete. Each data set contains $([long]$fileCount * $buffer.Length) bytes."
   

3. Confirm completion, then check the item count and total size of the large-file and small-file data sets.

   one.bin in the large folder is 1,000,000,000 bytes. The small folder contains 10,000 files of 100,000 bytes each. Check the folder properties for the total content bytes. A completion message alone does not verify that a later copy is correct.

A and B are created in one experimental folder. The same byte sequences are written in a single-file form and a divided form, and both data sets contain 1,000,000,000 bytes. The pseudorandom data avoids the extreme compressibility of an all-zero file, but it does not guarantee the performance characteristics of actual photos.

Create an uncompressed ZIP and record its creation time

Confirm that the previous generation step completed successfully and that $lab and $smallDir remain defined in the same PowerShell session. This procedure applies only to the generated ordinary files. Compress-Archive has limitations, including omission of hidden files, so do not use this example as a complete backup of an important folder.

1. Run the following code in the same PowerShell session.

   $zip = Join-Path $lab 'small.zip'
   $watch = [System.Diagnostics.Stopwatch]::StartNew()
   Compress-Archive -LiteralPath $smallDir -DestinationPath $zip -CompressionLevel NoCompression
   $watch.Stop()
   Write-Host "ZIP creation: $($watch.Elapsed.TotalSeconds) seconds"
   Write-Host "ZIP size: $((Get-Item -LiteralPath $zip).Length) bytes"
   

   NoCompression stores the files in the ZIP archive without compressing their contents. The archive still includes management information.[S7: Compress-Archive]

2. Record the seconds required to create the ZIP archive and the archive’s byte count.

   Confirm that small.zip was created. After extraction, the files appear within a small folder, so later item-count verification compares the contents of that folder. Exclude failed creation attempts and inspect the original experimental data and free space before retrying.

You now have C, which contains the same files as B, and a record of the ZIP creation time. Creating A and B is preparation for the experiment, but ZIP creation is a cost of the ZIP-based method and is included in that comparison.

Copy over the same path and measure the time until the files are usable

Keep the source and destination devices, connection, application, and concurrent load unchanged. You need permission and sufficient capacity to provide a new empty destination for every attempt. Verify contents after, and outside, the timed interval. The comparison’s goal is to make B and C usable at the same final destination.

flowchart TB
    accTitle: Procedure for aligning comparison conditions
    accDescr: Keep the path and method fixed, vary the order, copy several times to a new empty destination, and verify contents after completion.
    A["Same devices, path, and method"] --> B["New empty destination every time"]
    B --> C["Measure several times in varied order"]
    C --> D["Also verify count and contents"]

Figure 10: Do not mistake time saved by skipping an existing file for faster transfer.

1. Record the devices, path, copy method, and the device that performs extraction.

   Do not mix copies within one physical drive with copies between different devices. Do not use cloud files that are available only online, and keep antivirus and synchronization conditions unchanged. If the NAS cannot extract an archive itself, record the route as extraction by the PC to the shared destination.

2. Using File Explorer, copy A, B, and C individually to new, empty destinations.

   Do not use Move. Measure from the start of copying until the completion display closes, using the same rule for each case. Record elapsed time rather than an estimated remaining time or an instantaneous displayed speed. Do not include attempts that ask you to skip or overwrite existing files in an equal-condition comparison.

3. If C must be used as individual files, also measure extraction time.

   For a comparison that requires extracted files, add ZIP creation, transfer, and extraction time. Include the previously measured ZIP-creation time as the fixed creation cost for each comparison; record repeated reuse of one ZIP archive as a separate condition. Even with the same save destination, record whether extraction was performed by the PC or internally by the NAS.

4. Measure each case several times—for example, three times—in varied orders, then record both the median and the spread.

   A new destination does not clear the source-side cache. Record cases in which only the second read becomes faster and account for content-verification reads that can affect the next trial. This procedure observes trends resembling ordinary copying; it is not a strict measurement of uncached media performance.[S8: File Caching]

You retain the times and measurement conditions for A, B, and C. In the record table under Verification, use A as a control and compare B and C as methods of placing the same file set, considering only successful attempts when evaluating speed.

Compare robocopy concurrency when ZIP is unsuitable

Use the same PowerShell session in which the experimental data was created. Confirm that $smallDir points to that data, that logs can be written to $lab, and that the destination’s parent folder is writable. Keep the original data and create a new destination for every run. Do not add options that delete data, such as /MIR, /PURGE, or /MOVE.

flowchart TB
    accTitle: Overlap the waiting time of individual files
    accDescr: By processing multiple files concurrently, one file can be transferred while another is waiting.
    A["Process multiple files concurrently"] --> B["File A waits for a response"]
    A --> C["File B is transferred"]
    B --> D["Overlap waiting time"]
    C --> D

Figure 11: Concurrency overlaps waiting time; it does not make the network link or disk itself faster.

1. Confirm why ZIP is unsuitable, such as a need to use individual files immediately or repeatedly send changes.

   robocopy’s /MT option processes multiple files concurrently. While one operation waits for a response, another transfer can proceed, but this does not increase the speed of the network link or device itself.[S9: robocopy] [S4: Performance Tuning for SMB File Servers]

2. Change $targetRoot to a writable destination and run the following code.

   $targetRoot = '\\NAS\share\CopyLab' # Change this to your copy destination
   $runId = [guid]::NewGuid().ToString('N')
   $target = Join-Path $targetRoot ('small-mt8-' + $runId)
   $log = Join-Path $lab ('robocopy-' + $runId + '.log')
   robocopy $smallDir $target /E /MT:8 /R:1 /W:1 /XJ "/LOG:$log"
   $code = $LASTEXITCODE
   if ($code -ge 8) {
       throw "The copy reported a failure. Exit code=$code; log=$log"
   }
   Write-Host "Exit code=$code. Check the copied, skipped, mismatched, and failed counts in the log and verify the destination contents: $log"
   

   Replace the example NAS and share names. Using the same timing rule, measure from immediately before the command starts until it finishes, and retain both the displayed log path and exit code.

3. Compare /MT:1 with /MT:8 in the same way, holding every condition except concurrency constant.

   Each rerun creates a destination and log with a new GUID. The small-mt8 portion of the example folder name identifies the condition; when testing /MT:1, change that portion to small-mt1 so the records remain distinguishable. Do not change ZIP use and concurrency simultaneously; evaluate one change at a time.

   /MT:8 is a starting point for comparison, not an optimal value. Excessive concurrency can increase load on the remote system and can make copying slower. Do not treat errors as evidence of greater speed; inspect the log and destination contents.[S1: Slow SMB files transfer speed]

For the same B file set, you retain the time, log, and content-verification result for each concurrency level. An exit code of 8 or greater includes a failure and causes the example to stop, but an exit code from 0 through 7 still requires the verification below.

Verification

Evaluate completion in two separate ways: whether the contents are complete and whether the time required to make them usable under equal conditions became shorter. A copy-complete display or exit code is not a substitute for verifying integrity.

Compare item counts, contents, and command results

Expected results and where to return after a failure

Equal counts and sizes do not prove that contents are equal. When necessary, compare hashes of corresponding source and destination files outside the timed interval. Verification reads can affect subsequent cache state, so record when those reads occur.

flowchart TB
    accTitle: Verify contents before comparing times
    accDescr: Check counts and sizes, compare hashes when necessary, and do not count attempts containing mismatches or failures as successful speed improvements.
    A["Check count and size"] --> B{"Do they match?"}
    B -->|yes| C["Compare hashes when necessary"]
    B -->|no| D["Exclude the attempt and investigate"]
    C --> E{"Any mismatch or failure?"}
    E -->|no| F["Compare times under equal conditions"]
    E -->|yes| D

Figure 12: Check displayed speed and the correctness of copied contents separately.

robocopy options and exit codes

Microsoft’s robocopy documentation describes the options and exit codes. The default copied information includes data, attributes, and timestamps; this example is not a complete backup that preserves every item such as access control lists.[S9: robocopy]

Record actual measurements

Results table to complete

The following table intentionally contains no measured numerical results. Record the conditions, trial order, extraction location, and presence or absence of errors. Retain raw elapsed times and their variation rather than only a median.

Evaluate B and C on the condition that the same set of files can be used at the same final destination. Extraction is unnecessary if the ZIP archive is merely stored, but that is a different condition from using the individual files. If the distributions from repeated trials overlap, the results do not establish a speed improvement beyond the observed variation.

Distinguish slowness from failure

Determine whether only large groups of small files are slow, whether large files are also slow, and whether copying the same file locally is slow. If the transfer rate declines partway through, caching may also be involved; the displayed rate alone cannot identify the cause.[S8: File Caching] [S1: Slow SMB files transfer speed]

flowchart TB
    accTitle: Isolate the scope of copy slowness
    accDescr: Distinguish slowness limited to small files from slowness that occurs regardless of the data form.
    A{"Are only small files slow?"} -->|yes| B["Examine file count and waiting time"]
    A -->|no| C["Also examine devices, connections, and load"]
    B --> D["Also check failures and disconnections"]
    C --> D

Figure 13: Slow copying of small files is not the same as a copy failure or device malfunction.

If copying fails, the connection drops, or performance suddenly becomes much worse than before, do not explain the problem solely in terms of file count. Stop the comparison and prioritize preservation of important data while checking logs, connections, free space, and device status. In a managed environment, provide the conditions and logs to the responsible administrator.

After verification, remove the experimental data only after confirming that the displayed copylab folder and each trial destination are the data you created. No automatic deletion command is provided. Do not delete original photos or documents.

Limitations

What this comparison can and cannot establish

This explanation shows how file count can affect elapsed time; it is not a definitive diagnosis of the root cause on a particular device. The numerical examples are hypothetical, and the comparison procedures are not reported measurements. Changing ZIP use or concurrency is not guaranteed to improve performance.

Even with a new empty destination, operating-system read caches and device state are not fully equalized. The time until the copy window closes does not measure whether all writes would survive a power loss. Do not test this by unplugging an external device immediately; use the normal safe-removal procedure.[S8: File Caching]

Backup and protection features are separate requirements

The generated .bin files and uncompressed ZIP archive are comparison data. Compress-Archive has limitations such as omission of hidden files, and an ordinary robocopy invocation does not preserve every attribute and permission. Do not design a complete backup for important data solely from this speed comparison.[S7: Compress-Archive] [S9: robocopy]

This article does not recommend disabling antivirus protection or SMB signing to increase speed. SMB signing protects communications against tampering. Do not bypass settings on a managed PC; consult the responsible administrator.[S10: SMB signing overview]

Before purchasing a faster device, begin by examining the total size and file count, the actual copy path, and the complete time until the files are usable. Keep the decision about whether to adopt an optimization separate from verification that the copied contents are correct.

References

These sources were checked on September 17, 2026. The relevant support provided by each source is noted below. Configuration examples in server documentation are not intended for direct application by general users or to every NAS.

[S1] Microsoft Learn, Slow SMB files transfer speed. Supports the discussion of file-creation, communication, and inspection overhead for large numbers of small files, concurrent copying, and extracting an archive on the destination.

[S2] Microsoft Learn, CreateFileW function. Describes opening and creating files, requested access, and sharing modes.

[S3] Microsoft Learn, Master File Table. Describes how NTFS maintains management information for each file.

[S4] Microsoft Learn, Performance Tuning for SMB File Servers. Supports the discussion of robocopy concurrency and logging when copying small files.

[S5] Microsoft Open Specifications, Sending Compounded Requests. Describes how SMB2 can send multiple related operations together.

[S6] Microsoft Support, Zip and unzip files. Supports combining files in ZIP archives and notes that already compressed formats such as JPEG might not become much smaller.

[S7] Microsoft Learn, Compress-Archive. Describes NoCompression and limitations such as omission of hidden files.

[S8] Microsoft Learn, File Caching. Describes the system file cache and delayed write behavior.

[S9] Microsoft Learn, robocopy. Describes concurrency, retries, logging, copied information, and exit codes.

[S10] Microsoft Learn, SMB signing overview. Describes the protective purpose and operational role of SMB signing.

Related Articles

Recent articles sharing the same tags. Deepen your understanding with closely related topics.

Related Topics

These topic pages place the article in a broader service and decision context.

Where This Topic Connects

This article connects naturally to the following service pages.

Frequently Asked Questions

Common questions about the topic of this article.

Why does a photo folder copy slower even though the size is the same?

A copy is not just a transfer of contents. For every file, the destination file is created, its information is managed, it is closed, and so on. When there are many small files, the share of this processing and waiting grows. What matters is not the photo format itself but the number of files and the size of each one.

Do small files still copy slowly on an SSD or a fast LAN?

Yes. Even on an SSD the file management work remains, and when copying to a NAS or similar, the time spent waiting for the network and for the other side's processing is added. The speed of a continuous transfer of large files and the speed of handling many small files are two different things.

If JPEGs do not get smaller in a ZIP, is there any point in bundling them?

Even when the size barely shrinks, bundling the files to be transferred into one still has an effect. Creating and extracting the ZIP take time as well, though. For uses that require extraction, compare the total time of creation, transfer, and extraction.

Is it faster to send a ZIP to the NAS and then extract it into the shared folder from the PC?

With that method the PC writes the extracted small files to the NAS, so file creation across the network happens all over again. Distinguish this from extracting inside the NAS with a feature the NAS itself supports, and measure with the extraction included.

Does robocopy's parallel copy get faster the more threads you add?

No. Parallelism lets the per-file waits overlap, but it also increases the load on the storage or the NAS. Compare under the same conditions starting from a small number of threads, and check the log for copy failures and missed files as well.

Author Profile

Profile page for the article author.

Go Komura

Representative of KomuraSoft LLC

Focused on Windows software development, technical consulting, and investigations into failures that are difficult to reproduce.