Bits, Bytes, and Bandwidth: The Units Behind Every Spec Sheet

Quick answer
A bit is one binary digit; a byte is eight bits. Storage and file sizes are quoted in bytes, network speeds in bits per second.
That factor of eight is why a 1 Gbps connection tops out near 125 MB/s, not 1000 MB/s.
Kilo, mega, giga, and tera mean 1000 in decimal and 1024 in binary, and hardware vendors use one while your operating system uses the other.
A 512 GB drive showing 476 GB is not a scam: the manufacturer counted 512 billion bytes and the OS divided by 1024 three times.
Bandwidth and latency are different problems. Bandwidth is the width of the pipe; latency is how long a single trip takes, and more width does not shorten the trip.

Bits, bytes, and why the distinction matters

A bit is a single binary digit — a 0 or a 1 — and it is the smallest unit of information a computer handles. Bits get grouped into bytes, eight bits to a byte, because eight is enough to represent 256 distinct values: an ASCII character, a small integer, or one channel of a pixel. Everything you read about capacity, memory, and file size is measured in bytes; everything you read about network speed is measured in bits per second. The convention is worth internalising, because the two are everywhere and mixing them produces estimates that are wrong by a factor of eight.

In writing, the difference is a lowercase b versus an uppercase B. A download speed of 100 Mbps is 100 megabits per second, which is about 12.5 megabytes per second. A 500 MB file over that link takes around 40 seconds, not 5. This is not pedantry: it is the single most common reason an estimate of how long something will take is wrong, whether it is a database backup leaving the building or a container image being pulled on a slow connection.

Decimal and binary prefixes, and the missing gigabytes

The prefix kilo originally meant 1000, which is tidy for humans and awkward for computers, whose arithmetic works in powers of two. So two systems coexist. In decimal, 1 kilobyte is 1,000 bytes, 1 megabyte is 1,000,000, and 1 gigabyte is 1,000,000,000. In binary, 1 kibibyte is 1,024 bytes, 1 mebibyte is 1,048,576, and 1 gibibyte is 1,073,741,824. The binary prefixes exist to end the ambiguity, and almost nobody uses them in casual speech.

The practical consequence is the storage capacity you thought you lost. Drive vendors quote decimal sizes because the number is bigger, and operating systems report binary sizes because that is how they count. A drive sold as 512 GB contains 512,000,000,000 bytes, which a system dividing by 1024 three times displays as roughly 476 GiB — and many tools then label that number ‘GB’, inviting the accusation of theft. Memory is quoted in binary units, which is why the same file can appear to be a different size depending on whether you are looking at your laptop or a datasheet.

# Why a 512 GB drive shows ~476 GB
bytes_total = 512 * 1000**3
print(bytes_total / 1024**3, 'GiB')      # ~476.8

# Why 1 Gbps is ~125 MB/s
gigabits = 1
print(gigabits * 1000 / 8, 'MB/s')       # 125.0

Speed units: GHz, Mbps, MT/s, and IOPS

The unit tells you what dimension is being measured, and reading it carefully is most of the skill. Gigahertz is cycles per second, a rate of internal steps rather than of work completed. Megatransfers per second (MT/s) is how memory speed is properly quoted, describing how many data transfers happen per second, which is why DDR5-5600 pairs with a 5600 MT/s rating. Megabits and gigabits per second measure network throughput. Gigabytes per second measure how fast data can be moved to or from memory or a drive. IOPS measures operations per second, counting individual reads or writes rather than bytes, which is the right unit for random access.

Three of those are rates through a pipe and one — IOPS — is a count of round trips, so the numbers are not comparable to each other. It is also why a drive can advertise a huge gigabyte-per-second figure and still be slow for a database: the large number comes from big sequential transfers, while the database is sending small random requests whose cost is dominated by latency and queue depth. When you read a spec sheet, find the figure that matches your workload’s shape before you compare anything.

Reading a real specification line by line

Take a typical laptop listing: 16 GB DDR5-5600, 8 cores / 16 threads, 1 TB NVMe PCIe 4.0, RTX 4060 8 GB, 1 Gbps Ethernet. The first item is capacity and speed of working memory — 16 GB is enough to be comfortable, and 5600 MT/s describes how quickly it moves data. The second is the processor: eight physical cores presenting sixteen threads, which tells you the machine can run several things at once but that any single-threaded task uses one eighth of it. The third is a one-terabyte NVMe drive on the fourth generation of the PCIe interface, meaning fast local storage with plenty of room.

The last two are the ones people misread. The graphics card’s 8 GB is its own dedicated video memory (VRAM), not shared with the 16 GB of system RAM, and for AI work it is often the binding constraint. And the network figure is in bits: 1 Gbps is about 125 MB/s in each direction, which is fine for most applications and a real limit if your workload streams large files or synchronises a database offsite. Decoding each item into ‘how much’, ‘how fast’, and ‘how many’ is what makes two spec sheets comparable instead of merely impressive.

Where this bites vibecoders
Unit confusion costs real money when it turns into a sizing decision. An assistant that reads 1 Gbps as 1 GB/s will size a backup window eight times too optimistically, and one that compares a cloud volume’s GB/s figure against an NVMe drive’s GB/s figure will conclude they are equivalent when they are not. None of this is programming skill; it is the ability to read a number and know what dimension it measures. It is also the difference between reporting a page that loads in 200 ms because it is efficient and one that appears to load in 200 ms because the second request was cached and the first took four seconds.

Where AI coding assistants get this wrong

Estimating transfer times using bits and bytes interchangeably.
Comparing an IOPS figure against a throughput figure as if they measured the same thing.
Assuming advertised drive capacity equals usable capacity.
Reading a network speed in Gbps as gigabytes per second.
Confusing a GPU’s dedicated VRAM with system RAM.
Comparing MT/s, GHz, and GB/s as though they were the same kind of number.

Checklist

Check the unit before using a number in an estimate — bits or bytes, and what is being counted.
Convert network speeds to bytes per second before reasoning about transfer times.
Expect usable drive capacity to be smaller than the advertised figure.
Match the metric to the workload: IOPS for random access, throughput for large transfers.
Keep VRAM and system RAM separate when planning AI workloads.
Include protocol overhead when an estimate needs to be accurate.

FAQ

Why does my 1 TB drive only show 931 GB?

Because the manufacturer counted 1,000,000,000,000 bytes and your operating system divided by 1024 three times, which gives about 931. The drive really does hold a trillion bytes; the two sides are using different definitions of the same prefix. No space is missing, and the binary prefix for the smaller number would be TiB.

Is 100 Mbps fast enough to deploy over?

It depends entirely on the size of what you are moving. That link carries about 12.5 MB/s, so a 50 MB container image takes a few seconds and a 20 GB database backup takes around half an hour. For interactive work it is fine; for regularly shipping large artefacts it becomes the bottleneck.

What does MT/s mean, and how is it different from MHz?

Megatransfers per second counts how many data transfers happen each second, which is the meaningful figure for double-data-rate memory. MHz counts clock cycles. Because DDR moves data twice per cycle, a memory clocked at 2800 MHz performs 5600 MT/s, which is why the module is sold as DDR5-5600.