# Judging Pipeline Capacity Simulator

## PURPOSE
The Chroma Awards trailer promises Season 2 will be bigger — "more resources, bigger prizes,
an unforgettable awards ceremony." Bigger means more entries, and every entry must be watched
and scored by a human (or hybrid) judging panel before the ceremony date. This project is a
SimPy + NumPy discrete-event simulation that models the judging pipeline: entries arriving over
a submission window, queuing for reviewers, each review consuming a random amount of time, and
a hard deadline for the awards ceremony. It answers the question nobody likes to ask aloud:
*can our panels actually finish in time?*

## WHY THIS MATTERS
Throughput is invisible until it fails. Teams routinely discover the bottleneck the week before
awards night, when it is far too late to recruit reviewers. A simulation makes the queue visible
early — average wait per entry, reviewer utilization, and the probability the ceremony deadline
is missed — so staffing decisions are made with numbers, not optimism.

## HOW TO BUILD
Model entries as SimPy processes that request a shared `simpy.Resource` of reviewers. Draw
review durations and inter-arrival gaps from NumPy distributions, run many replications, and
collect statistics. Vary reviewer count to find the minimum that clears the backlog.

```python
import simpy, numpy as np

def entry(env, name, reviewers, durations, results):
    with reviewers.request() as req:
        yield req
        dur = durations
        yield env.timeout(dur)
        results.append(env.now)

env = simpy.Environment()
reviewers = simpy.Resource(env, capacity=8)
```

## WHEN TO USE IN PRODUCTION
Use it to capacity-plan any review-gated pipeline with a deadline: competitions, peer review,
content moderation, grant panels, code review. Do **not** use it when the system is genuinely
closed-form (a single M/M/c queue has an analytic answer) or when you already have months of
production telemetry — measure instead of simulate.

## HOW IT HELPS STUDENTS
Students learn discrete-event thinking, stochastic modeling with NumPy, resource contention,
and Monte-Carlo replication — highly transferable to operations, SRE, and platform roles.

## STARTER CODE
`starter/main.py` builds the SimPy pipeline with NumPy-sampled durations, runs replications,
and prints wait times and reviewer utilization. `# TODO` markers mark staffing sweeps and a
deadline-miss probability estimate.
