Why Every DevOps Engineer Must Learn NumPy This Year

Why NumPy matters for DevOps:

1. Data is already numeric
   - Response times, error rates, CPU %, memory, cost
   - These are arrays, not documents

2. Python loops are slow
   - A 1M-value loop in pure Python is visibly slow
   - NumPy pushes the loop into C

3. Scripts become short
   - 30 lines of loop logic become 3 lines
   - Fewer bugs, easier reviews

4. It fits your existing stack
   - Prometheus, Grafana, CloudWatch all export numbers
   - NumPy reads them and computes instantly

What changes when you use NumPy:

Before:
- You read a dashboard and guess the trend
- You write a loop to find slow endpoints
- You wait for a report to finish

After:
- You compute p95 and p99 in one line
- You flag anomalies with a z-score threshold
- You forecast next month's capacity
- You put the script in CI and it runs in seconds

The dashboard shows you data.
NumPy lets you ask questions of that data.

import numpy as np

# Response times in milliseconds
latency = np.array([120, 95, 210, 87, 430, 150])

# No loop: convert every value to seconds
seconds = latency / 1000

# No loop: flag anything above 200 ms
slow = latency > 200

print(seconds)
print(slow)

import numpy as np

latency = np.array([120, 95, 210, 87, 430, 150, 300])
status  = np.array([200, 200, 500, 200, 503, 200, 500])

# p95 latency in one call
p95 = np.percentile(latency, 95)

# Only error requests
errors = latency[status >= 500]

# Average error latency
avg_error = errors.mean()

print(p95, avg_error)

import numpy as np

# Response times collected from your APM export
latency = np.array([120, 130, 95, 210, 430, 150, 88, 990])

p50 = np.percentile(latency, 50)
p95 = np.percentile(latency, 95)
p99 = np.percentile(latency, 99)

print(f"p50={p50}  p95={p95}  p99={p99}")

# Worst offenders
print("Slowest:", np.sort(latency)[-3:])

import numpy as np

# Requests per minute for the last 24 hours
rpm = np.array([
    410, 420, 415, 430, 425, 440, 900, 425,
    430, 418, 422, 435, 428, 424, 419, 431
])

mean = rpm.mean()
std  = rpm.std()

# Z-score above 3 is a strong anomaly
z = (rpm - mean) / std
anomalies = np.where(np.abs(z) > 3)

print("Mean:", mean, "Std:", std)
print("Anomalies at index:", anomalies[0])
print("Values:", rpm[anomalies])

import numpy as np

# One day of 1-minute request counts and error counts
total  = np.array([1200, 1180, 1240, 1300, 1260, 1190])
errors = np.array([12, 9, 15, 40, 11, 8])

error_rate = errors / total

# SLO: 99.5% success means error rate <= 0.005
slo_error_rate = 0.005
breach = error_rate > slo_error_rate

print("Error rates:", np.round(error_rate, 4))
print("Breach minutes:", np.sum(breach))
print("Budget used %:", round(breach.mean() * 100, 2))

import numpy as np

# CPU utilisation samples from the last 6 hours
cpu = np.array([
    42, 44, 41, 43, 45, 44, 42, 91, 43, 44,
    42, 41, 46, 44, 43, 42, 45, 44, 43, 42
])

window = 5
threshold = 3.0

anomalies = []
for i in range(window, len(cpu)):
    history = cpu[i-window:i]
    mu, sigma = history.mean(), history.std()
    if sigma == 0:
        continue
    z = (cpu[i] - mu) / sigma
    if abs(z) > threshold:
        anomalies.append((i, cpu[i], round(z, 2)))

print("Anomalies (index, value, z-score):")
for a in anomalies:
    print(a)

import numpy as np

# Monthly peak requests (in thousands) for the last 12 months
peak = np.array([120, 128, 135, 140, 150, 158,
                 165, 172, 181, 188, 196, 205])

# Simple linear trend using least squares
x = np.arange(len(peak))
slope, intercept = np.polyfit(x, peak, 1)

next_month = len(peak)
forecast = slope * next_month + intercept

print("Monthly growth:", round(slope, 2), "k req")
print("Next month forecast:", round(forecast, 1), "k req")

# Capacity check against current limit
limit = 220
print("Headroom:", round(limit - forecast, 1), "k req")