Discrete-event simulation is a way to rehearse an operational redesign on a model before it reaches your staff or customers. You feed it three things ops already tracks (arrivals, service times, and routing) and it shows how queues and waits behave once the change is live.
The redesign passed the pilot. The simulation would have shown you where the backlog moved.
What is discrete-event simulation in operations?
Discrete-event simulation models a process as a series of events that happen at specific moments. A request arrives. A clerk starts work. The clerk finishes. The file moves on. The model clock jumps from one event to the next, and nothing is calculated in between. That is the "discrete" part.
Three families of input drive every run:
- Arrivals: how often work shows up, and how unevenly.
- Service times: how long each step takes, as a spread of values and not one average.
- Routing: where each item goes next, including the share that is rejected, reworked, or escalated.
Add the number of people at each step and a queue rule, usually first in, first out, and you have a working model. A run produces the numbers your dashboards already report: wait time, queue length, utilisation, and throughput. The difference is that you get them for a process that does not exist yet.
You will also see it called process simulation or what-if analysis for operations redesign. The job is the same: build a small copy of the process, change one thing, and watch what the queues do.
Why is a redesign a hypothesis about queues?
Every redesign makes a claim: if we change this step, work will flow better. That claim is about queues. Move capacity, shorten a service time, or change a routing rule, and queues shift. Some shrink. Some grow in a step nobody was watching.
Most teams test that claim after they ship. They run a pilot, watch the dashboard for the step they changed, and call the result learning. By then the redesign has staff working in it, customers waiting on it, and a project team that has already announced it.
A redesign is a hypothesis about queues. Rehearse it in a model before you run it on people. A mistake in a model costs a few minutes of computing time. A mistake in a pilot costs waiting customers, rework, and the floor's trust in the next change.
This post is the third layer in a short sequence. Bottleneck analysis tells you where the constraint sits today. Queueing theory for wait time gives you the maths for how waits behave as utilisation climbs. Simulation answers the question that comes next: what happens to the queue if the redesign ships.
A constructed example: the loan-document pilot
This story is illustrative. It is not a real client.
Consider a bank that automates loan-document checking. The pilot goes well. Checking time per file falls from twenty minutes to six, the checking queue empties, and the dashboard looks excellent. Two weeks later the credit-decision queue has more than doubled and analysts are staying late.
The old manual check sent incomplete files back to applicants. The automated check confirms a document is present, not that it is usable, so more files reach the analysts. The routing changed, nobody modelled it, and the pilot only measured the step that was redesigned.
A two-hour model run would have shown the migration. The worked example below rebuilds this case with numbers.
Worked banking example: automating the document check
Take an SME loan intake with two steps. The inputs below are the kind of figures any ops team can pull from existing dashboards and case-system timestamps.
| Input | Current process | Redesign |
|---|---|---|
| Arrivals | 8 applications per hour, random gaps | Same |
| Step 1: document check | 3 clerks, mean 20 minutes | 3 clerks, mean 6 minutes (automated check) |
| Routing after step 1 | 82% pass to credit, 18% returned incomplete | 90% pass, 10% returned |
| Step 2: credit decision | 4 analysts, mean 30 minutes | Same |
Service times are drawn from a skewed distribution, because real handling times have a long tail: most files take a normal time and a few take far longer. The tail matters more than the mean.
Check the arithmetic by hand first
Before any run, compute utilisation: arrival rate times mean service time, divided by the number of servers.
- Current document check: 8 × (20 ÷ 60) ÷ 3 = 89%.
- Current credit decision: (8 × 0.82) × 0.5 ÷ 4 = 82%.
- Redesign, credit decision: (8 × 0.90) × 0.5 ÷ 4 = 90%.
The hand check already shows the problem. The redesign moves credit decision from 82% to 90% utilisation, and waits grow sharply in that range. The model puts a number on how sharply.
What the run says
These figures are the average of 30 model runs, each covering 2,000 operating hours. They are model output for a constructed process, not client data.
| Measure | Current | Redesign |
|---|---|---|
| Wait for document check | about 32 minutes | under 1 minute |
| Credit decision utilisation | 82% | 90% |
| Mean wait for an analyst | about 16 minutes | about 48 minutes |
| 90th percentile wait for an analyst | about 50 minutes | about 126 minutes |
| Average files waiting for an analyst | 1.8 | 5.7 |
The pilot dashboard would have reported the first row: a 32-minute wait falling to nothing. It would not have reported the rest.
Add the two waits for a file that reaches an analyst. Currently it is about 32 plus 16, or 48 minutes. After the redesign it is under 1 plus 48, or still about 48 minutes. The redesign moved the wait. It did not remove it.
Run the what-if
Change one input at a time and rerun.
| What-if | Mean wait for an analyst | Files waiting |
|---|---|---|
| Redesign as specified (90% pass) | about 48 minutes | 5.7 |
| Tighten the automated rule so 85% pass | about 28 minutes | 3.2 |
| Redesign plus a fifth credit analyst | about 7 minutes | 0.9 |
The routing rule is a design decision, and it can be tested like capacity. The cheapest fix may also sit one step downstream of the change. You find that out in an afternoon, not after a quarter of backlog.
How does Little's Law sanity-check a simulation?
A simulation can be wrong in ways that look convincing. Little's Law is the first test of whether yours is sound.
Little's Law says that in a stable system, the average number of items in the system equals the arrival rate times the average time each item spends there. In symbols, L = λ × W.
Apply it to the waiting line in front of the analysts:
- Redesign arrival rate to credit decision: 7.2 files per hour.
- Mean wait: 47.8 minutes, or 0.797 hours.
- Expected average queue: 7.2 × 0.797 = about 5.7 files.
The model reports 5.7 files waiting, so the two agree. If your model's queue count and the arrival-rate-times-wait figure differ, the bug is in how you record timestamps or count items. Fix it before trusting any result.
Three more checks are worth running:
- Throughput equals arrivals. In a stable process, what leaves matches what arrives. If outputs fall short, a queue is growing without limit.
- Utilisation matches the hand calculation. Your model's busy-time share should land near the figure you computed above.
- The current process reproduces reality. Run the model of today's process and compare waits with what your dashboards say. If they differ materially, correct the inputs before you test any change. For the underlying maths, see queueing theory for wait time.
What can a simulation show that a pilot cannot?
A pilot is real, which is its strength. It is also short, small, and focused on the thing you changed. The list below is the one to bring to your next redesign review.
What a pilot can't see:
- Downstream migration. Work leaves the step you fixed and lands on the next one. A pilot dashboard usually tracks only the redesigned step.
- Variance effects. Average handling time can improve while the tail gets worse. Queues respond to variability, not only to the mean.
- Peak behaviour. A two-week pilot may never include a month-end surge or a post-holiday backlog. A model can replay one on demand.
- Warm-up bias. A pilot that starts with an empty queue understates steady-state waits. In the example above, a ten-day window from an empty start showed roughly 41 minutes at the analysts' desk, against 48 in steady state.
- Rare routes. A path taken by 2% of files appears a handful of times in a pilot. A model can run it thousands of times.
- Interactions between changes. Two sensible changes can collide. A model lets you test them alone and together.
- Cost of being wrong. A bad pilot touches live customers. A bad model run touches nothing.
None of this removes the need for a pilot, or for operators' judgement. The model tells you what to look for, and the pilot confirms it with real people.
Worksheet: build your first ops simulation
Copy this one. It takes one process, a few existing dashboards, and an afternoon. A spreadsheet or a few dozen lines of code is enough to run it.
Step 1: Define the entities and the scope
Choose one process of 3 to 6 steps. Decide what a unit of work is (an application, a payment, a ticket). Draw the steps in order.
| Step | Who does it | Number of people | Queue rule |
|---|---|---|---|
| 1. ______ | ______ | ___ | First in, first out |
| 2. ______ | ______ | ___ | First in, first out |
| 3. ______ | ______ | ___ | First in, first out |
Step 2: Pull arrivals from the dashboards you already have
Take 4 to 8 weeks of timestamps for when work enters the process.
- Average arrivals per hour: ______
- Busiest hour and its rate: ______
- Busiest day of the month and its rate: ______
- Gaps between arrivals: roughly random, or scheduled in batches? ______
Step 3: Pull service times, as a spread
For each step, take the time a person spends actively on the item, not the time it sits waiting.
| Step | Mean | Typical (median) | 90th percentile | Longest normal case |
|---|---|---|---|---|
| 1 | ___ | ___ | ___ | ___ |
| 2 | ___ | ___ | ___ | ___ |
If the mean is well above the median, the distribution has a long tail. Model that tail. It is where your worst waits come from.
Step 4: Set routing
For each step, write down where items go next and what share goes each way.
| From | To | Share |
|---|---|---|
| Step 1 | Step 2 | ___% |
| Step 1 | Returned or rejected | ___% |
| Step 2 | Rework or escalation | ___% |
Routing is the input teams most often skip, and it is the one that moved the backlog in the loan example.
Step 5: Validate the baseline
Run the current process. Then check three things.
- Does the model's mean wait match your dashboard within about 10%?
- Does Little's Law hold on every queue (L = λ × W)?
- Does throughput equal arrivals?
Do not test a redesign until the baseline passes.
Step 6: Run the what-if
Change one input at a time. Record the results.
| Change tested | Wait at each step | 90th percentile | Queue length | Downstream step affected? |
|---|---|---|---|---|
| ______ | ___ | ___ | ___ | ___ |
Then ask the review question: which queue got worse, and by how much? If nothing got worse, check that the routing and service-time inputs for the changed step are realistic.
Step 7: Decide and set pilot measures
Use the run to choose what to pilot, and write down in advance which downstream measures the pilot must track. Link those measures to your cycle-time analysis and to the targets you will hold the process to under SLA and cycle-time enforcement.
Where does simulation fit in the 7-step AI Lean Cycle?
ESSAM's 7-step AI Lean Cycle runs Baseline, Map, Analyse waste, Optimise, Document, Deploy, and Improve, and then repeats. The first three steps produce what a simulation needs: a baseline of real timings, a map of the steps and routes, and a waste classification for each step. The model rehearses the Optimise step before you commit to Document and Deploy.
The E-S-S-A-M framework matters here too. It stands for Eliminate, Simplify and Standardise, Automate, and Migrate. Automate is the fourth action on purpose: you design before you automate. The loan example is what happens when a team jumps to Automate without testing what it does to routing.
Once a redesign is live, work instructions go to the floor over WhatsApp, and the timestamps from real work flow back into the baseline. That closes the loop. The model improves as the data does. The features page shows how single-session capture and the before/after audit view support that loop.
The size of move worth rehearsing
This one is real. At a Kuwait bank, a procurement cycle fell from 139 days to 57 days, a 59% reduction. That retired 82 days of work with the same headcount. The gain came from Eliminate and Simplify, before any automation.
No simulation claim is made for that case. It is cited for scale. A move of that size reshapes queues across several steps, so it is worth rehearsing before you ship it. It was a procurement cycle only, not a promise for other functions.
Frequently asked questions
What is discrete-event simulation used for in banking?
Banks use it to test changes to queues and capacity before committing: branch staffing, loan processing, payment exceptions, onboarding, and complaints handling. It suits any process where work arrives at random, waits for people, and moves between steps.
Do I need data science skills to run a process simulation?
No. You need arrivals, service times and routing, which your case system and dashboards already record. The skill lies in choosing realistic inputs and checking the baseline, not in advanced statistics.
How is simulation different from a pilot or an A/B test?
A pilot changes the live process and watches the result. A simulation changes a model and watches the result. The model is faster, free of customer impact, and able to replay peaks and rare paths. The pilot is real. Use the first to decide what to try, and the second to confirm it.
Rehearse the queue before you change it
A redesign is a claim about how work will queue. You can test it on a model, where mistakes are free, or on your people, where they are not. The three inputs are already in your dashboards.
Book a walkthrough of how ESSAM captures a process in one session and prepares it for rehearsal at apac.essam.ai
