A 10Gbps server can be slow because the client, storage, CPU, application, or network path cannot sustain the requested rate. Start by checking speed units and link speed. Then compare controlled tests in both directions while measuring CPU use, interface errors, and TCP behavior.
A fast server port is only one part of a transfer. The receiving device, remote network, and software must also keep up.
We recommend working from the symptom to a controlled test. Each result should narrow the search before you change a setting. This guide uses Linux examples and explains what the results can and cannot prove.
Start Here: Match Your Symptom to the Next Test
| What you see | Possible causes | What to check next |
|---|---|---|
| Transfers stay around 110–120 MB/s | A 1Gbps segment, storage limit, or configured cap | Check both endpoints, link rates, and service limits |
| One connection is slow, but several are faster | A per-flow limit, CPU processing, TCP behavior, or different flow paths | Compare one and four streams while watching individual CPU cores |
| A network test is fast, but file copies are slow | Storage, encryption, application behavior, or different traffic policies | Compare disk activity and application CPU use during the copy |
| Only one destination is slow | Remote endpoint limits, routing, congestion, or filtering | Repeat the same test against another approved endpoint |
| Uploads and downloads differ | Sender or receiver limits, directional policies, or different paths | Reverse the transfer and monitor both hosts |
| Performance drops at busy times | Competing workloads, shared capacity, or queue buildup | Compare host and network metrics at matching timestamps |
| One CPU core stays busy | A worker thread, packet-processing queue, or encryption limit | Check per-core use and the process handling traffic |
| Small requests work, but large transfers stall | MTU problems, filtering, or application issues | Check path MTU and whether the problem follows packet size |
| Latency rises during a transfer | Queues filling on a host or network device | Compare latency before, during, and after the load |
| An intermediate MTR hop shows loss | Limited diagnostic replies or real forwarding trouble | Check later hops and compare with application symptoms |
These are starting points. A speed plateau or counter by itself does not identify the faulty component.
Step 1: Define What “Slow” Means
Record the affected task before running a benchmark. A slow webpage, an SFTP copy, and a backup job need different checks.
Write down:
- The source and destination.
- The protocol or application.
- The direction of the transfer.
- The observed rate and its unit.
- The time, date, and time zone.
- Whether the issue affects one user, one destination, or every transfer.
- Whether the problem is new and what changed before it started.
For a website, separate slow response time from slow file delivery. A database query can delay the first byte even when the network has spare capacity.
Check Gbps, MB/s, and MiB/s
Network plans usually show gigabits per second. File tools often show megabytes per second. There are eight bits in one byte.
| Link rate | Raw decimal byte rate before overhead |
|---|---|
| 1Gbps | 125 MB/s |
| 10Gbps | 1,250 MB/s |
These figures are conversions, not promised application results. Ethernet, IP, transport headers, and other overhead reduce the rate available for file data. MiB/s uses a different unit from MB/s, so compare like with like.
A download at 100 MB/s is about 800 Mbps. That measurement alone cannot tell us whether storage, a client connection, or a network policy sets the limit.
Check What Your Plan Actually Provides
Review the port speed, transfer allowance, traffic policies, and any committed bandwidth. “Unmetered” describes a billing arrangement. It does not remove endpoint limits or make every Internet path a 10Gbps path.
For a virtual machine, distinguish the host uplink from the guest’s allowed rate. A virtual adapter reporting a high speed does not prove that the VM has that capacity reserved.
Our 10Gbps vs. 1Gbps dedicated server comparison explains the capacity difference. Troubleshooting still requires measurements for the actual workload.
Step 2: Check Both Endpoints and the Active Link
A 10Gbps server cannot send a file at 10Gbps to a client whose connection tops out at 1Gbps. The same applies to an overloaded receiver or a remote service with a download cap.
Use a second endpoint with known spare capacity. A nearby test host helps reduce the number of network variables. Later, repeat the test against a remote endpoint that represents your users.
Identify the Interface Used by the Transfer
Replace TEST_SERVER_IP with the test endpoint’s address:
ip route get TEST_SERVER_IP
ip -br link
The route result identifies the selected interface for that destination. Policy routing, containers, tunnels, and multiple interfaces can make this different from the interface you expected.
For IPv6, use the matching IPv6 route lookup and keep the address family consistent across comparisons.
Next, replace INTERFACE with the relevant interface name:
ethtool INTERFACE
ethtool -i INTERFACE
ip -s link show dev INTERFACE
ethtool -S INTERFACE
Check the reported speed, link state, driver information, and available error counters. Some commands need elevated permissions. Virtual interfaces may not expose the underlying physical link details.
A reported speed of 10000Mb/s confirms the local link rate when the driver reports it correctly. It does not measure the complete path to a customer.
Compare Counters Before and After a Test
Old errors can remain in counters long after an incident. Capture the values before the transfer, then compare them after it finishes.
Separate physical errors from other drops:
- Rising CRC or frame errors can point toward a cable, optic, port, or signal problem.
- Receive drops can involve queues, buffers, driver behavior, or a host that cannot process incoming traffic quickly enough.
- Counter names and meanings vary by adapter and driver.
For a dedicated server, ask the provider to check the switch side when the host counters suggest a physical issue. Include the test time so the provider can match its records.
If the adapter or server hardware changed recently, also check the supported transceiver or cable type and the negotiated PCIe link width and speed. A capable NIC still needs enough bandwidth through its host connection.
Step 3: Run a Controlled Network Test
A normal iperf3 test helps separate network transfer performance from file reads and writes. It does not reproduce every part of an HTTPS download, VPN session, or backup job.
Use endpoints you own or have permission to test. Run high-rate tests in an agreed window because they can consume capacity used by customers. Start with a rate-limited test if spare capacity is uncertain.
The commands below are diagnostic examples, not published benchmark results.
Prepare the Test
Record the installed version on both hosts:
iperf3 –version
Use compatible iperf3 installations. Starting with version 3.16, iperf3 uses a separate thread for each test stream. Older builds can behave differently under parallel load. See the ESnet iperf3 FAQ.
On the receiving test host, restrict TCP port 5201 to the source host in the firewall. Bind the listener to its intended local test address:
iperf3 -s -B LOCAL_TEST_IP
Replace the capitalized placeholders with real addresses. Do not expose an unrestricted test listener to the Internet.
Compare One Stream, Several Streams, and Both Directions
Run these tests separately from the client. -R makes the listening server send data back to the client. -P 4 uses four parallel streams. -J saves JSON output. The examples use 30 seconds per test.
iperf3 -c TEST_SERVER_IP -P 1 -t 30 -J > forward-one.json
iperf3 -c TEST_SERVER_IP -P 4 -t 30 -J > forward-four.json
iperf3 -c TEST_SERVER_IP -P 1 -t 30 -R -J > reverse-one.json
iperf3 -c TEST_SERVER_IP -P 4 -t 30 -R -J > reverse-four.json
These commands do not set a traffic cap. Use the installed iperf3 manual to choose rate limits for your environment. Stop the listener with Ctrl+C and remove the temporary firewall access when testing ends.
Record the receiving side’s throughput, retransmission information where available, and host metrics. Repeat an inconsistent result under the same conditions before treating it as a baseline.
Read the Results as a Pattern
| Test pattern | What it suggests | Next action |
|---|---|---|
| One and four streams both perform well | The tested endpoints and path can carry that load at that time | Compare the real application’s storage and processing |
| Four streams outperform one | The single-flow result has a limit that parallel traffic partly avoids | Check TCP state, per-core CPU use, and flow distribution |
| Both directions perform poorly | A shared endpoint or path limit remains possible | Check host counters, CPU, configured caps, and a second endpoint |
| Only one direction performs poorly | Sending and receiving conditions differ | Compare CPU, disk involvement, policies, and paths in each direction |
| Nearby tests work; remote tests do not | The issue depends on the remote endpoint or wider path | Compare RTT, TCP behavior, routing, and remote capacity |
A strong parallel result does not prove that one file transfer will reach the same rate. Parallel flows can use more processing resources and may follow different network paths.
Keep send and receive results separate. Adding them together does not describe one-way throughput.
Step 4: Check Storage and the Application
If iperf3 performs well but a file copy does not, inspect the parts that differ between the two tests.
The sender must read the data. The receiver must process and store it. A slow stage can hold back the whole transfer.
Watch Disk Activity During the Actual Copy
On Linux, tools from the sysstat package can show storage activity:
iostat -xz 1 5
Review read and write rates, request latency, and queue behavior on both systems. Do not diagnose a modern SSD or RAID array from %util alone. Device parallelism and workload type affect how that number relates to capacity.
Check for:
- Backups, snapshots, or RAID rebuilds running at the same time.
- High write latency on the receiving system.
- Many small files that require frequent metadata work.
- Filesystem or device errors.
- Storage quotas and low free space.
- A fast first transfer followed by slower sustained transfers.
The last pattern can involve memory caching or a device’s write cache. A short burst does not establish the sustained rate.
Use a representative dataset and record whether it was cached. Avoid clearing production caches just to produce a benchmark. Do not run write tests against a raw device containing live data.
Check Protocol and Application Limits
SFTP, HTTPS, SMB, and backup software do different work. Encryption, compression, checksums, synchronous writes, and per-user limits can affect throughput.
For example, a large sequential file and a directory containing thousands of small files are different workloads. The directory copy may spend much of its time opening files and updating metadata.
If compression is enabled, compare its CPU cost with its benefit for your data. Already compressed media often leaves little room for further size reduction. Keep required encryption and access controls in place while testing.
A fast iperf3 result also does not rule out protocol-specific traffic policies. Your application may use a different port, proxy, tunnel, or destination from the test.
Step 5: Check CPU Use Per Core
Average CPU use can hide the bottleneck. On a many-core server, one busy core may limit a transfer while the system-wide percentage stays low.
During the affected workload, run:
mpstat -P ALL 1 5
pidstat -u 1 5
These tools also come from sysstat. Check both endpoints.
Look for a busy application worker, encryption process, or high soft-interrupt processing on individual cores. On a VM, CPU steal time can indicate that the guest is waiting for host CPU time.
Check Packet Processing and Queue Distribution
A NIC can distribute incoming flows across receive queues. Linux Receive Side Scaling and related mechanisms help spread work across CPUs. The result depends on the adapter, driver, traffic, and configuration. The Linux kernel networking guide explains these relationships.
Inspect supported queue information and offload settings:
ethtool -l INTERFACE
ethtool -k INTERFACE
Some adapters do not support these queries. A missing feature or command error does not by itself prove a fault.
Do not turn every offload off or set every queue count to its maximum. First identify which CPU or queue is overloaded. Then choose a change that fits the hardware and measure its effect.
Account for Packet Size and Middleboxes
The same bit rate requires more packets per second when packets are smaller. A server that handles large bulk transfers well may struggle with a packet-heavy VPN, game, or proxy workload.
Firewalls, NAT, virtual switches, tunnels, and traffic inspection add work between the application and physical NIC. Test the path your users actually take. A successful test outside a VPN does not measure encrypted tunnel capacity.
Step 6: Examine TCP Behavior, Loss, and Latency
TCP throughput depends partly on how much data can remain unacknowledged while the sender waits for replies. Higher round-trip time makes this more demanding. Loss and limited windows can also reduce throughput. ESnet describes these links in its TCP performance guide.
Inspect active TCP connections during the transfer:
ss -ti
Match the output to the test connection. Depending on the kernel and connection state, it can show RTT, congestion-window information, and retransmission details.
Use the Bandwidth-Delay Product as a Check
The bandwidth-delay product estimates the amount of data needed in flight at a target rate:
Bytes in flight = target bits per second × round-trip time in seconds ÷ 8
For a 10Gbps target:
| RTT | Calculated data in flight |
|---|---|
| 10 ms | 12.5 MB |
| 40 ms | 50 MB |
| 100 ms | 125 MB |
These are decimal calculations before protocol overhead. They are not instructions to assign those values to every socket buffer. Application behavior, receive-window limits, congestion control, and operating-system memory management also matter.
Interpret Retransmissions Carefully
Rising retransmissions during a slow transfer deserve investigation. They can reflect lost data, but reordering and spurious retransmissions can complicate the picture.
Possible loss sources include congestion, an overloaded receiver, a firewall, and physical faults. ESnet’s packet-loss troubleshooting reference covers these causes.
Compare retransmissions with interface counters, CPU use, and the transfer timeline. A retransmission total cannot identify the router or cable responsible.
Also compare latency at idle and under load. If latency climbs while a transfer fills the connection, queues may be building. More bandwidth or larger buffers are not automatic fixes for every queueing problem.
Step 7: Check MTU and Routing
The maximum transmission unit, or MTU, sets the largest IP packet an interface can send without the relevant fragmentation behavior. Tunnels add headers and can reduce the usable size for traffic inside them.
Investigate MTU When the Symptoms Fit
MTU trouble is worth checking when small requests work but larger transfers stall, especially after a VPN, tunnel, or network change.
Check the local interface MTU:
ip link show dev INTERFACE
If available, use tracepath to gather path information:
tracepath TEST_SERVER_IP
Filtering can prevent useful replies. A failed probe is not enough to prove an MTU mismatch.
Do not set MTU 9000 across a public Internet path as a general speed fix. Jumbo frames need support across the relevant network segment. For a tunnel, check its overhead, the inner MTU, and whether required path-MTU signals can reach the sender.
If you change an interface that carries your management connection, keep console access and a clear recovery method available.
Compare Routes Without Blaming the First Silent Hop
A bounded MTR report can help document a route:
mtr -n -r -c 50 TEST_SERVER_IP
Record the test time and protocol. Default diagnostic probes may receive different treatment from application traffic.
An intermediate router can limit replies to probes while forwarding traffic normally. Loss that appears at one hop and disappears at later hops does not establish forwarding loss at that router. Cloudflare’s MTR explanation shows this distinction.
Even missing destination replies need context. Compare them with application failures, retransmissions, and endpoint behavior. Collect reports from both ends when possible because the return path may differ.
For a useful routing comparison, keep the workload and settings fixed. Change only the destination or test time. A single public speed-test result is weak evidence because its endpoint load and selected route can change.
Step 8: Apply One Fix and Repeat the Original Test
A useful correction addresses the measured limit. It should improve the affected workload without creating another problem.
| Evidence | Possible corrective action | What to measure afterward |
|---|---|---|
| A local link reports 1Gbps where 10Gbps is expected | Correct the port configuration or incompatible physical component | Link rate, error counters, and throughput |
| Physical error counters rise during transfers | Have the provider inspect the cable, optic, and switch port | Error-counter changes during the same load |
| Disk latency rises as file throughput falls | Address storage contention or the storage design | Sustained application transfer rate and disk latency |
| One application worker reaches its CPU limit | Review supported worker settings or CPU requirements | Per-core use and application response time |
| Host drops rise with packet-processing load | Review queues, CPU distribution, and supported driver settings | Drops, CPU use, and packet-heavy workload behavior |
| Only one remote path performs poorly | Share comparable tests with the relevant providers | Results to the affected destination at matching times |
| A documented traffic cap matches the observed ceiling | Adjust the policy or service capacity if required | The same test within the revised allowance |
Before each change, save the current configuration and record how to restore it. Change one variable at a time. If the result worsens or fails to improve, restore the previous state before trying another change.
Repeat the original application task as well as the network test. Better benchmark numbers are not enough if users still face slow downloads or timeouts.
What to Send Your Hosting Provider
A clear support request helps the team reproduce the problem and compare its network records with yours.
Use this template:
Server identifier:
Affected application or protocol:
When the issue started:
Test date, time, and time zone:
Source and destination addresses:
Traffic direction:
Expected result and basis for that expectation:
Observed result and units:
Test commands and tool versions:
Single-stream and parallel-stream results:
Nearby and remote endpoint results:
Per-core CPU observations:
Storage observations:
Interface-counter changes during the test:
TCP or route observations:
Recent changes:
Business impact:
Send diagnostic files through the provider’s private support channel. Remove credentials, tokens, and unrelated customer data. Packet captures can contain sensitive information, so agree on their scope before collecting or sharing them.
If you host with Atal Networks, include these details in your support request. If measurements show that your workload needs a different hardware or network allocation, review our 10Gbps dedicated server options and discuss the measured requirement with our team.
Frequently Asked Questions
Why am I getting about 1Gbps on a 10Gbps server?
A client connection, intermediate link, traffic policy, or endpoint resource may limit the transfer. Check both link rates and compare a controlled network test with the real application. A result near 1Gbps does not identify the limiting component by itself.
Should a 10Gbps server transfer files at 1,250 MB/s?
That figure is the raw bit-to-byte conversion before overhead. Real file throughput depends on the protocol, path, storage, CPU, and receiving system. Set an acceptance target for your specific workload and test conditions.
Why is iperf3 fast while SFTP is slow?
SFTP includes file reads, writes, encryption, and application processing that a normal iperf3 test does not reproduce. Check disk latency and per-core CPU use during the copy. Also check whether both tests use the same route and traffic policy.
Why do parallel connections improve throughput?
Several flows can use more processing resources and avoid a limit affecting one flow. They may also take different paths through load-balanced equipment. The result shows aggregate performance for those flows, not the speed available to every single connection.
Does distance make 10Gbps impossible?
Distance increases latency, which raises the amount of data needed in flight to sustain a target rate. Loss, endpoint capacity, and TCP behavior also matter. Distance alone is not a fixed throughput ceiling.
Will jumbo frames fix a slow 10Gbps connection?
Only consider them where the network supports them and measurements justify the change. An inconsistent MTU can cause failures. For Internet traffic, investigate path MTU and tunnel overhead before changing interface settings.
Does MTR packet loss prove that my provider is dropping traffic?
No. A router may limit diagnostic replies while forwarding application traffic normally. Compare later hops, endpoint behavior, retransmissions, and tests from both directions before assigning a cause.
Should I upgrade the server before troubleshooting?
Measure the bottleneck first. More CPU can help a CPU-bound workload, and faster storage can help a storage-bound workload. Neither change fixes a slow client connection or an unrelated remote path limit.
