Preface

This article is a cheatsheet and a collection of tips/tricks for doing back of the envelope calculations.

Numbers

Data Types to Bytes

Note: keep in mind that these are general estimates. Depending on the language that implements them, the actual size stored in memory may vary.

Data Type	Byte(s)	Explanation
CHAR	1-4 bytes	1 byte is enough to cover all the characters in ASCII and then some (1 byte = 255 character choices). Some languages that allow Unicode characters (144,697 character choices) will have to allocate more bytes per character, so some languages may use up 2-4 bytes rather than just 1.
BOOL	1 byte	True or False state can technically be represented by 1 bit, but the CPU can't address anything smaller than a byte.
INT	4 bytes	Decimals range from $[-2^{31}, 2^{31}]$. Up to ~4 billion numbers. Each byte has 8 bits, so $\frac{32}{8} = 4$
BIGINT	8 bytes	It uses twice the number of bits as INT and doubles the ranges of INT, so it is called a BIGINT. Decimals of range $[-2^{63}, 2^{63}]$ can now be stored.
FLOAT	4 bytes	Same number of bytes as INT. In SQL, precision is supported up to 0 to 23 decimal places. Single precision.
DOUBLE	8 bytes	It uses twice the number of bits as FLOAT, so its called a DOUBLE. FLOAT has accuracy issues due to its limited floating point precisions that can't be widely represented under 4 bytes.
DATETIME	8 bytes	Contains date and time. A four-byte integer for date packed as `YYYY×10000 + MM×100 + DD` and a four-byte integer for time packed as `HH×10000 + MM×100 + SS`. Some implementations make this size more compact (down to 5 bytes in newer versions of SQL) but 8 bytes is a reasonable estimate for a DATETIME value.

Size Tables

Pre-requisites: See the chart here for a quick primer on numbers.

Number (numerical)	Number (english)	Power	Byte
1	One	$10 ^ 0$	1 byte
1,000	Thousand	$10 ^ {3}$	1 KB (1 kilobyte)
1,000,000	Million	$10 ^ {6}$	1 MB (1 megabyte)
1,000,000,000	Billion	$10 ^ {9}$	1 GB (1 gigabyte)
1,000,000,000,000	Trillion	$10 ^ {12}$	1 TB (1 terabyte)
1,000,000,000,000,000	Quadrillion	$10 ^ {15}$	1 PB (1 petabyte)

Time Tables

Millisecond ($10^{-3}_{sec}$)	$1_{sec} = 1,000_{ms}$
Microsecond ($10^{-6}_{sec}$)	$1_{sec} = 1,000,000_{μs}$
Nanosecond ($10^{-9}_{sec}$)	$1_{sec} = 1,000,000,000_{ns}$

Time to Seconds

Hour	Day	Month	Year
$60 * 60 = 3600$	$3600 * 24 = 86400$	$86400 * 30 = 2592000$	$2592000 * 12 = 31104000$
3600 secs	approx. ~85k secs	approx. ~2.5 million secs	approx. ~30 million secs

ISO8601

Requests

Requests	Requests per second
$\text{2.5 million}_{req/month}$	$\text{1}_{req/sec}$
$\text{86,400}_{req/day}$	$\text{1}_{req/sec}$

This is all you need to know really. There are 2.5 million seconds in 1 month. This means that with 1 request per second, you have 2.5 million requests in that whole month.

Most request counts (for a month) usually range from millions to billions, so having this back-of-the-envelope formula should get you started for easy conversions.

Availability

99.9% availability - three 9s

Duration	Acceptable downtime
Downtime per year	8h 45min 57s
Downtime per month	43m 50s
Downtime per week	10m 5s
Downtime per day	1m 26s

99.99% availability - four 9s

Duration	Acceptable downtime
Downtime per year	52min 36s
Downtime per month	4m 23s
Downtime per week	1m 5s
Downtime per day	9s

In sequence formula

Overall availability decreases when two components with availability < 100% are in sequence:
Availability (Total) = Availability (Foo) * Availability (Bar)

In parallel formula

Overall availability increases when two components with availability < 100% are in parallel:

Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))

Latency to Remember

These numbers from System Design Primer is a good reference sheet to remember when designing systems.

Actions	Nanoseconds	Microseconds	Milliseconds
Blazing Fast
L1 cache reference	$0.5 ns$
Branch misredirect	$5 ns$
L2 cache reference (L1 is about 14x faster)	$7 ns$
Mutex lock/unlock	$25 ns$
Main Memory Reference (20x slower than L2 cache)	$100 ns$
Very Fast
Compress 1 KB (i.e. with Zippy)	$10,000 ns$	$10 μs$
Send 1 KB over 1 Gbps network	$10,000 ns$	$10 μs$
Read 4 KB randomly from SSD	$150,000 ns$	$150 μs$	$0.15 ms$
Read 1 MB sequentially from memory	$250,000 ns$	$250 μs$	$0.25 ms$
Round trip within same datacenter	$500,000 ns$	$500 μs$	$0.5 ms$
Read 1 MB sequentially from SSD (~1 GB/sec SSD, 4 times slower than RAM)	$1,000,000 ns$	$1,000 μs$	$1 ms$
Somewhat fast
HDD seek (i.e. 7200 RPM disk drives)	$10,000,000 ns$	$10,000 μs$	$10 ms$
Read 1 MB sequentially from 1 Gbps network	$10,000,000 ns$	$10,000 μs$	$10 ms$
Read 1 MB sequentially from HDD	$30,000,000 ns$	$30,000 μs$	$30 ms$
Send a packet CA -> Netherlands -> CA	$150,000,000 ns$	$150,000 μs$	$150 ms$