151 free computer it calculators and tools. Solve real-world computer it problems instantly with accurate, step-by-step results on ApexCalc.
Convert binary (base-2) numbers to decimal (base-10). Each bit position contributes 2^n. E.g., 1011₂ = 8+0+2+1 = 11₁₀.
Convert decimal (base-10) integers to binary (base-2) by repeated division by 2. Remainders read bottom-up give the binary representation.
Convert hexadecimal (base-16) values to decimal. Each hex digit (0–F) represents 4 bits. E.g., FF₁₆ = 15×16+15 = 255₁₀.
Convert decimal integers to hexadecimal (base-16) by repeated division by 16. Used for memory addresses, color codes, and binary data.
Convert octal (base-8) numbers to decimal. Each octal digit represents 3 bits. Commonly used in Unix file permissions (e.g., 755).
Convert binary to hexadecimal by grouping 4 bits from the right. Each 4-bit nibble maps to one hex digit (0–F).
Calculate the two's complement of an 8-bit signed integer. Range: -128 to +127. Negate by flipping all bits and adding 1.
Calculate the two's complement representation of a 16-bit signed integer. Range: -32,768 to +32,767. Widely used in audio and embedded systems.
Encode/decode IEEE 754 single-precision floats: 1 sign bit, 8 exponent bits (bias 127), 23 mantissa bits. Value = (-1)^s × 2^(e-127) × 1.mantissa.
Encode/decode IEEE 754 double-precision floats: 1 sign bit, 11 exponent bits (bias 1023), 52 mantissa bits. Provides ~15-17 significant decimal digits.
Convert an ASCII code (0–127) to its corresponding character. ASCII defines 128 characters including control codes (0–31) and printable characters (32–127).
Convert any printable character to its ASCII decimal, hex, and binary codes. Useful for encoding, debugging, and low-level programming.
Look up the Unicode code point (U+XXXX) for any character, including emoji, mathematical symbols, and international scripts.
Calculate how many bytes a string occupies in UTF-8. ASCII uses 1 byte; Latin extended 2 bytes; CJK 3 bytes; emoji typically 4 bytes.
Compute the bitwise AND of two integers. Each output bit is 1 only when both input bits are 1. Used for masking bits and extracting flag values.
Compute the bitwise OR of two integers. Each output bit is 1 when at least one input bit is 1. Used for setting flags and combining bitmasks.
Compute the bitwise XOR (exclusive OR) of two integers. Output bit is 1 when inputs differ. Used in encryption, checksums, and swap-without-temp algorithms.
Compute the bitwise NOT (one's complement) of an integer. Flips every bit. For a 32-bit integer n, NOT n = -(n+1) in two's complement arithmetic.
Calculate the result of left-shifting an integer by n positions. Equivalent to multiplying by 2^n. Bits shifted out are lost; vacated bits filled with 0.
Calculate the result of right-shifting an integer by n positions. Logical shift fills with 0; arithmetic shift preserves the sign bit. Equivalent to floor division by 2^n.
Count the number of 1 bits (set bits) in an integer. Known as popcount or Hamming weight. Used in error correction, cryptography, and data compression.
Calculate the Hamming distance between two binary strings or integers: the number of bit positions where they differ. Equals popcount(a XOR b).
Compute the Hamming weight of a binary string — the number of symbols differing from zero. Identical to population count for binary data.
Determine the even or odd parity bit for a binary string. Parity bit ensures the total number of 1s is even (even parity) or odd (odd parity), enabling single-bit error detection.
Compute the CRC-8 (Cyclic Redundancy Check) checksum for a byte sequence using polynomial 0x07. CRC detects burst errors and is used in serial communication protocols.
Calculate the maximum addressable memory given a register width n: 2^n bytes. A 32-bit register addresses 4 GB; a 64-bit register addresses 16 EB theoretically.
Calculate cache hit ratio and effective memory access time (EMAT). EMAT = hit_rate × cache_time + miss_rate × memory_time. Higher hit ratios dramatically reduce average latency.
Calculate the number of sets in an N-way set-associative cache. Sets = Cache_Size / (N × Line_Size). Determines index bits needed for cache addressing.
Calculate the effective memory access time accounting for TLB hit/miss rates. TLB miss requires a page table walk adding 10–200 ns penalty depending on page table depth.
Calculate instructions per second from clock frequency and cycles per instruction (CPI). IPS = Clock_Frequency / CPI. Modern CPUs execute multiple instructions per cycle (IPC > 1).
Calculate ideal pipeline throughput for an N-stage CPU pipeline. Throughput = 1 instruction per clock in steady state. Speedup vs non-pipelined = N (ideal, no hazards).
Calculate the effective CPI impact of branch mispredictions. CPI_effective = CPI_ideal + branch_frequency × miss_rate × pipeline_flush_penalty.
Estimate the IPC improvement from out-of-order execution. OOO CPUs reorder instructions to avoid stalls from data dependencies, improving utilization of execution units.
Calculate theoretical speedup from SIMD (Single Instruction Multiple Data) vectorization. Speedup = SIMD_width / scalar_width. AVX-512 processes 16 floats simultaneously vs 1 in scalar code.
Calculate maximum parallel speedup using Amdahl's Law: Speedup = 1 / (S + (1-S)/N), where S is the serial fraction and N is the number of processors. Diminishing returns with more cores.
Calculate scaled speedup from Gustafson's Law: Speedup = N - S×(N-1), where N is processors and S is the serial fraction. Unlike Amdahl's, assumes problem scales with processor count.
Calculate memory bandwidth: Bandwidth = bus_width × frequency × channels × transfers_per_clock. DDR5-6400 dual-channel delivers ~102 GB/s theoretical peak bandwidth.
Calculate DRAM access latency in nanoseconds from CAS latency (CL) and memory frequency. Latency_ns = (CL / (frequency/2)) × 1000. DDR5-6400 CL32 ≈ 10 ns.
Estimate SRAM cache access latency at different levels (L1, L2, L3). Typical values: L1 ~1 ns (4 cycles @ 4GHz), L2 ~3 ns (12 cycles), L3 ~10 ns (40 cycles).
Compare NVMe and SATA SSD latencies. NVMe via PCIe 4.0 achieves ~20–100 µs latency and 7 GB/s sequential reads; SATA III caps at ~600 MB/s with 50–200 µs latency.
Compare sequential and random I/O performance for storage devices. HDDs: random IOPS limited by seek time (~100 IOPS); SSDs: 10K–1M random IOPS. IOPS = 1 / (seek_time + rotational_latency + transfer_time).
Calculate latency increase from storage queue depth using Little's Law: L = λW. Higher queue depth increases IOPS but raises average latency. NVMe saturates around QD32–128.
Calculate SSD write amplification factor (WAF): WAF = NAND_writes / host_writes. WAF > 1 reduces SSD lifespan. High WAF is caused by random small writes and low over-provisioning.
Estimate JVM/CLR garbage collection pause frequency and duration based on heap size, allocation rate, and GC algorithm. Stop-the-world pauses = heap_size / (alloc_rate × GC_efficiency).
Calculate hash collision probability using the birthday approximation: P(collision) ≈ 1 - e^(-n²/2H), where n is items and H is hash space size (2^bits).
Calculate hash table load factor α = n/m (n items, m buckets) and expected collision rate. At α=0.75 (Java HashMap default), expected chain length ≈ 0.75 with 47% collision probability.
Calculate minimum and maximum B-tree height for n entries and order t: height_min = ⌈log_2t(n+1)⌉ - 1, height_max = ⌊log_t((n+1)/2)⌋. Database indexes use B-trees for O(log n) lookups.
Calculate the number of comparisons for binary search on a sorted array of n elements: max comparisons = ⌊log₂(n)⌋ + 1. For 1 million elements: max 20 comparisons.
Calculate the expected number of comparisons for quicksort: approximately 2n × ln(n) on average with random pivot selection. Worst case O(n²) with sorted input.
Calculate the exact number of merge sort comparisons: between n⌈log₂n⌉ - 2^⌈log₂n⌉ + 1 (best) and n⌈log₂n⌉ - n + 1 (worst). Always O(n log n) regardless of input.
Calculate the worst-case comparisons for inserting into a binary heap: O(log n) = ⌊log₂(n+1)⌋ comparisons (sift-up). Heap extraction (delete-min) is also O(log n).
Calculate RAID-0 (striping) array capacity. Total capacity = N × drive_size. All capacity is usable but there is zero redundancy — any drive failure loses all data.
Calculate RAID-1 (mirroring) usable capacity: Total = drive_size (mirrored pair uses only 50% of raw capacity). Survives failure of all but one drive.
Calculate RAID-5 usable capacity: (N-1) × drive_size. One drive's worth of space stores distributed parity. Minimum 3 drives required; survives 1 drive failure.
Calculate RAID-6 usable capacity: (N-2) × drive_size. Two parity blocks (P and Q) enable survival of any 2 simultaneous drive failures. Minimum 4 drives required.
Calculate RAID-10 (stripe of mirrors) usable capacity: N/2 × drive_size. Combines RAID-0 performance with RAID-1 redundancy. Minimum 4 drives; survives at least 1 failure per mirror pair.
Calculate actual disk IOPS consumed per logical write in RAID-5. Each write = 4 physical IOPS (read old data, read old parity, write new data, write new parity). Actual_IOPS = Logical_IOPS × 4.
Compare IOPS per drive type. HDD 7200 RPM: ~100 random IOPS; SAS 15K RPM: ~200 IOPS; SATA SSD: ~90,000 IOPS; NVMe SSD: up to 1,000,000 IOPS.
Calculate storage array throughput: Throughput_MB/s = IOPS × block_size. A SAN with 10,000 IOPS at 512 KB block = 5,000 MB/s. Sequential bandwidth depends on block size.
Compare NAS and SAN access latencies. SAN (iSCSI/FC): 0.1–2 ms block-level access. NAS (NFS/SMB): 1–10 ms file-level access with protocol overhead. NVMe-oF approaches local NVMe latency.
Calculate the time required to complete a backup: Time = data_size / (throughput × efficiency). A 10 TB full backup at 1 GB/s with 80% efficiency takes ~3.5 hours.
Estimate full backup storage requirements including compression and deduplication ratios. Backup_size = raw_data × (1 - dedup_ratio) × (1 - compression_ratio). Typical combined savings: 40–70%.
Calculate incremental backup size based on daily change rate. Incremental_size = full_backup_size × daily_change_rate. Typical enterprise change rate: 1–5% per day.
Calculate storage savings from data deduplication. Savings = 1 - (1 / dedup_ratio). A 5:1 dedup ratio saves 80% of storage. Formula: unique_data = total_data / dedup_ratio.
Calculate storage savings from data compression. Savings% = (1 - compressed_size/original_size) × 100. Text compresses ~70%; database rows ~50–60%; already-compressed files ~0%.
Calculate network link utilization: Utilization% = (traffic_bits_per_second / link_capacity_bps) × 100. Sustained utilization above 70–80% causes queuing delays and packet loss.
Calculate the TCP Bandwidth-Delay Product (BDP): BDP = bandwidth × RTT. The BDP is the amount of data that can be in-flight (unacknowledged) on a network path at any time.
Calculate the required TCP window scaling factor to achieve target throughput over a given RTT. Required_window = throughput × RTT. Scaling_factor = ⌈log₂(window / 65535)⌉.
Calculate Ethernet frame overhead percentage. With preamble (8B), header (14B), and FCS (4B), a 64-byte minimum frame has 40.6% overhead; a 1500-byte payload has only 1.7% overhead.
Calculate VLAN trunk bandwidth efficiency with 802.1Q tagging overhead. 802.1Q adds a 4-byte tag to each frame; efficiency = payload / (payload + all_headers + tag).
Calculate usable host addresses from a CIDR prefix. Hosts = 2^(32-prefix) - 2 (subtract network and broadcast addresses). /24 = 254 hosts; /16 = 65,534 hosts.
Calculate the broadcast address of a subnet from an IP address and CIDR prefix. Broadcast = network_address OR NOT(subnet_mask). For 192.168.1.0/24, broadcast = 192.168.1.255.
Calculate the network address by ANDing the IP address with the subnet mask. For 192.168.1.100 with /24 mask (255.255.255.0): network = 192.168.1.0.
Calculate the summary route (supernet) prefix that covers multiple contiguous subnets. Find common prefix bits by XOR-ing networks and finding the highest differing bit. Used to reduce BGP table size.
Understand and calculate BGP best path selection attributes. BGP prefers paths in order: Highest WEIGHT → Highest LOCAL_PREF → Shortest AS_PATH → Lowest MED → eBGP over iBGP.
Estimate DNS cache hit rate based on TTL and query frequency. Cache_hit_probability ≈ 1 - (query_interval / TTL). Lower TTL = more recursive queries; higher TTL = longer propagation delay for DNS changes.
Calculate CDN cache offload percentage and origin bandwidth savings. Offload% = (CDN_served_requests / total_requests) × 100. High cache-hit ratio (>90%) dramatically reduces origin server load.
Calculate load balancer session stickiness impact on distribution. With N backend servers and sticky sessions, session affinity reduces effective load distribution. Skew factor ≥ 1 / active_users_per_server.
Calculate available rack units (U) and power for server deployments. Standard rack = 42U. Each U = 1.75 inches. Plan for servers, switches, patch panels, UPS, and cable management.
Calculate rack power density in watts per rack unit (W/U) and kilowatts per rack (kW). Standard data centers support 5–10 kW/rack; high-density GPU racks require 30–100 kW/rack.
Calculate cooling requirements in BTU/hr from server power. 1 kW of IT load = 3412 BTU/hr. A 10 kW rack requires 34,120 BTU/hr (10-ton) cooling capacity. Always add 20% safety margin.
Calculate data center Power Usage Effectiveness: PUE = total_facility_power / IT_equipment_power. PUE 1.0 is perfect; industry average is ~1.58. Hyperscalers (Google, Meta) achieve PUE ~1.1.
Calculate UPS battery runtime: Runtime ≈ (battery_capacity_Wh / load_W) × efficiency. A 10 kWh UPS at 5 kW load with 90% inverter efficiency gives ~1.8 hours runtime.
Calculate diesel generator fuel consumption: Consumption (L/hr) = load_kW × 0.27 (at full load, diesel). A 500 kW generator at 70% load consumes ~94 L/hr of diesel.
Calculate colocation data center cost per kW per month. Typical ranges: Tier II: $100–$200/kW/mo; Tier III: $150–$300/kW/mo; Tier IV: $250–$500/kW/mo. GPU-dense: $400–$800/kW/mo.
Calculate annual data center operating expense per server including power, cooling (PUE factor), colocation or space cost, maintenance, and networking. Total OPEX = power_cost + space_cost + maintenance.
Calculate optimal VM density per physical host. VM_density = min(vCPU_capacity/vm_vcpus, RAM_capacity/vm_ram). Typical ratios: 4:1 vCPU overcommit (general workloads), 1:1 RAM (no overcommit).
Compare container vs VM overhead. Containers share the host kernel (10–50 MB overhead); VMs run full OS (1–2 GB RAM, 30–60 s boot time). Container density is typically 5–10× higher.
Calculate Kubernetes cluster capacity and pod scheduling. Total_pods = ∑(node_capacity / pod_request). With resource requests: allocatable_CPU = node_CPU - system_overhead - DaemonSet_usage.
Calculate memory overcommit ratio and assess risk of OOM (Out Of Memory) events. Overcommit_ratio = allocated_virtual_memory / physical_RAM. Safe ratios depend on workload memory usage patterns.
Calculate the effective CPU performance loss from hypervisor steal time on VMs. Steal time % = CPU cycles requested by VM but not served by hypervisor due to other VM competition.
Determine whether a disk is saturated using USE method: Utilization = (busy_time / total_time) × 100. Saturation = average queue depth > 1. For HDDs, utilization >70% causes latency spikes.
Estimate required storage IOPS for different application tiers. OLTP databases: 5–50 IOPS/user; web servers: 0.1–1 IOPS/RPS; email: 0.5–2 IOPS/mailbox; VDI: 15–20 IOPS/desktop.
Calculate storage cost savings from hot/warm/cold tiering. Typical costs: NVMe (hot): $0.10–0.30/GB/mo; SATA HDD (warm): $0.01–0.03/GB/mo; tape/object (cold): $0.003–0.006/GB/mo.
Calculate tape backup restore time. Restore_time = data_size / tape_throughput + seek_time + mount_time. LTO-9: up to 400 MB/s native. Large restores from tape: hours to days.
Calculate disaster recovery cost vs RTO/RPO targets. Lower RTO (faster recovery) and lower RPO (less data loss) require more expensive solutions: hot standby > warm standby > cold standby > tape.
Calculate total storage needed for the 3-2-1 backup rule: 3 copies of data, 2 different media types, 1 offsite. Storage = (primary_data × 3) with dedup/compression reducing actual footprint.
Calculate per-core software licensing costs and compare licensing models. Oracle Database: $25,000/core (EE); SQL Server: $3,700/core (SE) to $7,400/core (EE). Multiply by processor core factor.
Calculate total software licensing cost based on per-seat or per-user pricing. Total_cost = seats × price_per_seat × (1 + maintenance_rate). Typical maintenance: 18–22% annually.
Compare 5-year total cost of ownership between SaaS and on-premise deployment. On-premise TCO = hardware + licenses + staff + maintenance. SaaS TCO = subscriptions + integration + migration.
Calculate IT helpdesk staffing needs based on ticket volume. Industry benchmark: 1 L1 technician per 50–100 users (100–150 tickets/mo per FTE). Automation and self-service can double this ratio.
Estimate how page load time increases bounce rate. Google data: 1s load = 32% bounce; 3s = 90% bounce; 5s = 106% bounce. Each 100 ms delay costs ~1% in conversion rate.
Calculate Largest Contentful Paint (LCP) score. Good: ≤2.5s; Needs improvement: 2.5–4.0s; Poor: >4.0s. LCP measures when the main content of a page finishes loading.
Calculate Cumulative Layout Shift (CLS) score. Good: ≤0.1; Needs improvement: 0.1–0.25; Poor: >0.25. CLS measures unexpected visual shifts of page content during load.
Interaction to Next Paint (INP) replaced FID in March 2024. Good: ≤200ms; Needs improvement: 200–500ms; Poor: >500ms. INP measures responsiveness for all interactions, not just the first.
Estimate JavaScript parse + compile time from bundle size. Rule of thumb: 1 MB of JS takes ~1 s to parse on a mid-range mobile device. Parse time ≈ bundle_KB / 1000 × device_factor.
Estimate image load time from file size and connection speed. Load_time_s = file_size_MB × 8 / bandwidth_Mbps. A 500 KB image on 4G (20 Mbps): 0.5 × 8 / 20 = 0.2 s.
Calculate file size savings from converting JPEG to WebP or AVIF. WebP: 25–35% smaller than JPEG at equivalent quality. AVIF: 40–50% smaller. Both support transparency (unlike JPEG).
Calculate page weight and LCP improvement from lazy loading below-fold images. Lazy loading defers images outside the viewport until they are near-viewport, reducing initial page weight.
Calculate total load time from HTTP request count and latency. Total_time = num_requests × (RTT + server_processing) / parallelism. HTTP/1.1 allows 6 parallel connections; HTTP/2 multiplexes all.
Calculate the throughput benefit of HTTP/2 multiplexing vs HTTP/1.1. HTTP/2 sends multiple streams over one TCP connection, eliminating head-of-line blocking at the HTTP layer.
Calculate critical rendering path length: time from navigation start to first render. Determined by the longest chain of blocking resources (HTML parse → CSS → render-blocking JS → first paint).
Calculate and assess Time to First Byte. TTFB = DNS_lookup + TCP_connect + TLS_handshake + server_processing + network_transfer. Good: <800ms; Poor: >1800ms (Google Lighthouse).
Calculate P50, P95, and P99 server response times from latency distributions. P99 = slowest 1% of requests. For SLA purposes, P99 < 500ms is a common target for web APIs.
Calculate latency reduction from CDN caching. CDN_latency = local_PoP_RTT + edge_processing (1–10 ms). Origin_latency = user_RTT + TTFB. CDN reduces latency by 50–90% for global users.
Convert network RTT to end-user latency for different protocols. HTTP/1.1: 2×RTT for new connections. HTTP/2 with TLS 1.3: 1×RTT (0-RTT possible). QUIC (HTTP/3): 0-RTT on known hosts.
Estimate database query time from rows scanned, index usage, and I/O. Indexed lookup: O(log n) = <1ms. Full table scan of 1M rows: ~100–500ms. Index the columns in WHERE, JOIN, and ORDER BY clauses.
Calculate the database query overhead from N+1 anti-pattern. N+1 = 1 query to fetch N records + N queries for related data = N+1 total queries. For 100 records, 101 queries vs 1 JOIN query.
Calculate the probability and timing of database connection pool exhaustion. Pool_utilization = (active_connections / pool_size) × 100. At >90%, timeout errors increase exponentially.
Calculate database index selectivity: Selectivity = unique_values / total_rows. High selectivity (>0.9) = effective index. Low selectivity (< 0.2) = index often not used. Boolean columns have selectivity ~0.5.
Understand PostgreSQL query planner cost units. Cost = seq_page_cost × pages_scanned + cpu_tuple_cost × rows_processed. Default: seq_page_cost=1.0, random_page_cost=4.0. Lower cost = preferred plan.
Calculate Redis cache hit ratio and its impact on database load. Cache_hit_ratio = keyspace_hits / (keyspace_hits + keyspace_misses). A 90% cache hit ratio reduces database load by 10×.
Calculate Memcached throughput. A single Memcached server handles 200,000–500,000 ops/s for small keys. Throughput scales with worker threads and connection count up to CPU limits.
Calculate Kafka consumer lag: Lag = latest_offset - consumer_offset per partition. High lag indicates consumers cannot keep up with producers. Time to clear lag = lag / (consumer_rate - producer_rate).
Calculate message queue processing lag using Little's Law: N = λW. Queue_depth = arrival_rate × avg_processing_time. A queue with 1000 msgs/s arrival and 2ms processing has depth = 2.
Calculate RabbitMQ throughput capacity. Single node: up to 20,000–50,000 messages/s for small messages with persistence. Without persistence: 100,000+ msgs/s. Throughput depends on message size and ack mode.
Compare gRPC and REST API latency and throughput. gRPC (HTTP/2 + Protobuf): 5–10× faster serialization, 3–5× smaller payload vs REST+JSON. Best for high-frequency internal service communication.
Calculate bandwidth savings from GraphQL vs REST. GraphQL returns exactly requested fields, eliminating over-fetching. REST endpoints typically return 2–10× more data than mobile clients need.
Calculate API rate limit requirements and token bucket parameters. Rate_remaining = limit - requests_in_window. Token bucket: tokens replenish at rate_per_second. Fixed window vs sliding window vs token bucket.
Calculate optimal OAuth 2.0 access token expiry and refresh token strategy. Short-lived access tokens (5–60 min) minimize exposure; refresh tokens (days to months) must be rotated on use.
Calculate JWT token size from payload claims. JWT = base64url(header) + "." + base64url(payload) + "." + signature. A typical JWT with 10 claims is 300–500 bytes. Sent in every HTTP request header.
Calculate bcrypt hashing time from cost factor. Time ≈ 2^cost / baseline_hashes_per_second. Cost 10: ~100ms; cost 12: ~400ms; cost 14: ~1600ms. Higher cost = slower brute-force attacks.
Calculate TLS handshake latency overhead. TLS 1.2: 2 RTTs to establish. TLS 1.3: 1 RTT (0-RTT for resumption). RSA: slower key exchange vs ECDHE. Session resumption (tickets) saves 1 RTT.
Calculate latency savings from HTTP/3 QUIC over HTTP/2 TCP. QUIC combines transport + TLS in one handshake (1-RTT) vs TCP+TLS (2-3 RTTs). 0-RTT resumption for returning connections eliminates setup latency.
Calculate performance overhead of service mesh sidecar proxies (Istio, Linkerd, Envoy). Typical overhead: 1–4ms added latency per hop, 5–10% CPU overhead per sidecar, 50–300 MB RAM per sidecar.
Compare monolithic vs microservices request latency. Monolith: in-process calls ~1 µs. Microservices: network calls ~1–10 ms each. For N service calls, added latency = N × (RTT + processing).
Calculate circuit breaker parameters: failure_rate_threshold (e.g., 50%), wait_duration (e.g., 60s), and ring_buffer_size (minimum calls before evaluation). Based on Hystrix/Resilience4j patterns.
Calculate exponential backoff with jitter retry delay. Delay = min(cap, base × 2^attempt) + random(0, jitter). Jitter prevents thundering herd when many clients retry simultaneously.
Calculate blue-green deployment rollback time: Rollback = time to switch load balancer from green to blue environment. With DNS routing: 0-60s (instant switch, TTL-dependent). With sticky sessions: drain time + switch.
Calculate canary deployment traffic split and error rate exposure. Risk = canary_traffic_percentage / 100 × error_rate. A 10% canary split with 5% error rate affects 0.5% of users during testing.
Calculate feature flag gradual rollout stages and user impact. Rollout 1% → 5% → 20% → 50% → 100% over hours/days, monitoring metrics at each stage before proceeding.
Calculate A/B test traffic allocation and required sample size for statistical significance. Sample_size = 16 × σ² / δ² (for 80% power, 5% significance). 50/50 split maximizes statistical power.
Calculate how an error rate impacts your SLO (Service Level Objective). Error_budget_consumed = (error_rate / allowed_error_rate) × period. 99.9% SLO = 0.1% error budget; 1% error rate consumes 10× the budget in 1/10 the time.
Calculate and interpret latency percentiles from a distribution. P50 (median), P95, P99, P99.9. For log-normal distributions: P99 ≈ P50 × 4–10. Percentiles reveal tail latency invisible in averages.
Analyze the throughput-latency tradeoff using Little's Law: N = λW. As throughput approaches system capacity, latency increases non-linearly (queuing theory). At 90% utilization, latency doubles.
Calculate horizontal scaling efficiency: Efficiency = ideal_speedup / actual_speedup. Factors reducing efficiency: load balancer overhead, shared state contention, deployment coordination, and uneven shard distribution.
Calculate cost efficiency of vertical vs horizontal scaling. Large instances often have better price/performance ratio than many small instances for stateful workloads. Cost/request = instance_cost / requests_per_second.
Compare container vs VM startup times. Docker container from pre-pulled image: 100–500ms. VM boot: 30–90s. Container startup dominates cold scaling time; optimize with minimal base images and fast init.
Calculate serverless function cold start probability based on invocation rate and container lifetime. P(cold start) ≈ 1 - e^(-rate × lifetime). AWS Lambda: cold starts occur when no warm instance is available.
Apply Amdahl's Law to web application bottlenecks. Speedup = 1 / (S + (1-S)/N), where S is the non-scalable fraction (e.g., database writes). A 10% serial DB write fraction caps scaling at 10× regardless of servers.
Estimate CDN cache warm-up time and origin load during the warm-up period. All requests miss cache until PoPs are populated. Warm-up load = total_requests × (1 - cache_hit_ratio_at_time_t).