Skip to content
←Back to Blog
October 4, 2026•6 min read•By Dzaki Amri Zaidaan

Reasons I Didn't Become an EMT, Ranked: A Systems Engineering Postmortem

A ranked technical postmortem of why I didn't pursue EMT certification, framed as a systems engineering analysis of latency, error budgets, and human-in-the-loop reliability. Includes a production-grade Python model for evaluating high-stakes career decisions under uncertainty.

#Architecture#AI & ML
an ambulance parked on the side of the road

1. The Problem & Industry Shift

Choosing a career is a high-stakes, irreversible deployment. In systems terms, it's a one-way door with a long feedback loop and a catastrophic failure mode: burnout. I evaluated EMT certification as if it were a production service, and the SLOs didn't close. This post ranks the reasons I didn't become an EMT, using the same rigor I'd apply to a distributed system.

The industry shift is real: emergency medical services are moving toward community paramedicine and tele-EMS, where software (triage algorithms, dispatch optimization) increasingly handles the cognitive load. But the core constraints—human latency, emotional bandwidth, and physical presence—remain hard limits. Understanding why I opted out is a lesson in capacity planning for human operators.

2. Architecture & Core Mechanics

I modeled the decision as a pipeline with four stages: Training, Certification, Field Operations, and Long-Term Sustainability. Each stage has a failure probability and a cost. The overall system reliability is the product of stage reliabilities.

[Interest] --> [Training (150+ hrs)] --> [Certification (NREMT)] --> [Field Ops (12-hr shifts)] --> [Sustainability]
     |               |                        |                           |                        |
     v               v                        v                           v                        v
  Curiosity      Time cost              Pass rate ~70%              Burnout rate ~30%      Career pivot

Key mechanics:

  • Training: 150–200 hours, often unpaid, with a 20–30% attrition rate.
  • Certification: NREMT exam pass rate ~70% on first attempt [1].
  • Field Ops: 12-hour shifts, 50%+ time on paperwork, and exposure to traumatic events.
  • Sustainability: National EMT turnover is ~30% annually; many leave within 5 years [2].

This is a system with high coupling and low tolerance for error. The human operator is the bottleneck.

3. Production Code Example: Decision Model

I wrote a Monte Carlo simulation to quantify the expected value of becoming an EMT versus staying in software engineering. The model accounts for income, hours, burnout probability, and personal utility weights.

# decision_model.py
# Monte Carlo simulation for career decision: EMT vs Software Engineer
# Assumptions based on BLS data [3] and personal utility weights

import numpy as np
from dataclasses import dataclass

@dataclass
class CareerPath:
    name: str
    annual_income: float
    hours_per_week: float
    burnout_prob: float  # annual probability of leaving due to burnout
    utility_weight: float  # personal preference multiplier (0-1)

def simulate_career(path: CareerPath, years: int = 10, n_sims: int = 100_000) -> np.ndarray:
    """Return array of total utility over `years` for each simulation."""
    total_utility = np.zeros(n_sims)
    for sim in range(n_sims):
        utility = 0.0
        for year in range(years):
            # Income utility: log scale to reflect diminishing returns
            income_util = np.log1p(path.annual_income) * path.utility_weight
            # Time penalty: hours beyond 40/week reduce utility
            time_penalty = max(0, path.hours_per_week - 40) * 0.5
            # Burnout check: if burnout occurs, career ends and utility drops
            if np.random.random() < path.burnout_prob:
                utility += income_util - time_penalty - 50  # burnout penalty
                break
            utility += income_util - time_penalty
        total_utility[sim] = utility
    return total_utility

# Parameters (approximate, US-based)
emt = CareerPath(
    name="EMT",
    annual_income=35000,
    hours_per_week=50,
    burnout_prob=0.30,  # 30% annual turnover [2]
    utility_weight=0.8  # high personal satisfaction from helping others
)

swe = CareerPath(
    name="Software Engineer",
    annual_income=120000,
    hours_per_week=45,
    burnout_prob=0.10,
    utility_weight=0.6
)

emt_utils = simulate_career(emt)
swe_utils = simulate_career(swe)

print(f"EMT mean utility: {emt_utils.mean():.2f}, 5th percentile: {np.percentile(emt_utils, 5):.2f}")
print(f"SWE mean utility: {swe_utils.mean():.2f}, 5th percentile: {np.percentile(swe_utils, 5):.2f}")

Critical engineering decisions:

  • Log utility for income: Reflects diminishing marginal utility, a standard assumption in economics [4].
  • Burnout as absorbing state: Once burnout occurs, the career path terminates; this models the irreversible exit.
  • Monte Carlo: Captures tail risk (5th percentile) rather than just expected value.

4. Performance, Cost & Trade-offs

MetricEMTSoftware Engineer
Median annual income$35k$120k
Training cost (time)150–200 hrs0 (already skilled)
Burnout rate (annual)~30%~10%
Physical riskHighLow
Schedule flexibilityLowHigh
Emotional loadHighModerate

Latency vs. accuracy trade-off: EMTs must make split-second decisions with incomplete information. Software engineers can iterate. The cost of an error in EMS is immediate and irreversible; in software, it's often recoverable via rollback.

Memory usage: The human brain has limited working memory. EMTs must retain protocols, drug dosages, and patient histories under stress. This is akin to running a service with a small heap and no garbage collection—prone to OOM (overload) errors.

Security considerations: Personal safety is a non-negotiable constraint. EMTs face physical and verbal assault; software engineers face phishing and burnout. The threat model differs, but both require defense in depth.

5. Actionable Checklist / Summary

If you're evaluating a high-stakes career pivot, treat it as a systems design problem:

  • Define SLOs: What are your must-haves (income, hours, impact)?
  • Model the pipeline: Map stages and failure probabilities.
  • Run a Monte Carlo: Simulate 10 years with tail risks.
  • Quantify burnout: Use industry turnover data as a proxy.
  • Check reversibility: Is this a one-way door? If so, demand higher confidence.
  • Consult primary sources: BLS, NREMT, and peer-reviewed studies.

Ranked reasons I didn't become an EMT:

  1. Burnout probability (30% annual) – unacceptable tail risk.
  2. Income-to-hours ratio – poor utility per hour.
  3. Training opportunity cost – 200 hours unpaid.
  4. Emotional load – no graceful degradation.
  5. Physical risk – no rollback.
  6. Schedule rigidity – no horizontal scaling.
  7. Career ceiling – limited upward mobility without further investment.

6. References

← Explore More ArticlesShare on X / Twitter →