Advanced & Operational Analytics for USL’s ISURA Case Workflow

Text · Monte Carlo · Forecasting · Survival · Optimisation

Author

Affiliation

Emmanuel Nkenwokeneme

Union Systems Limited (USL)

Published

19 May 2026

1 Executive Summary

Union Systems Limited (USL) services six Nigerian banks from a portfolio of four proprietary applications (KACHASI v2.x, KACHASI v1.x, TENTACLES and DATASTORE) on multi-year licence contracts totalling an estimated USD 3.75 m of annual recurring revenue. Real ISURA case data (n = 5,035 closed cases) reveal a median resolution of 41 hours, but a long right-tail (max 8,424 h ≈ 351 days) and an overall SLA-breach rate well above the 25 % target. Date-parseable cases span June–December 2025, showing a pronounced downward trend from 712 cases in June to 208 in December — with case volume declining roughly 71 % over that window — which makes capacity planning the single largest operational lever. This report applies five Advanced & Operational Analytics techniques to that dataset: text analytics on the 5,035 real ISURA case titles to surface trending themes and an auto-triage baseline, Monte Carlo on revenue at risk under four investment scenarios, Holt forecasting of monthly volume, Cox proportional- hazards on time-to-SLA-breach, and a linear-programming optimisation of one squad-sprint of engineering capacity. The integrated finding: a Comprehensive intervention (new support pod + automation playbooks, USD 110 k investment) is recommended for board approval at the next quarterly review on the strength of its tail-risk reduction.

2 Professional Disclosure

I am Emmanuel Nkenwokeneme, Chief Technology Officer at Union Systems Limited (USL), a privately-held Nigerian banking-software vendor in the Financial Services / Enterprise Software sector. USL serves six commercial banks: First City Monument Bank (FCMB), Stanbic IBTC, Wema Bank, Coronation Merchant Bank, Signature Bank and Fidelity Bank. The five techniques in this paper map directly to live operational decisions on my desk:

Text Analytics. Roughly 5,000 free-text ISURA cases land in USL’s customer-success queue per year. Text analytics turns the case-title corpus into themed roadmap input, auto-routes tickets to the right product squad, and flags Central Bank of Nigeria (CBN) compliance cases before they age past their SLA window.
Monte Carlo. With six concentrated B2B customers, a single lost renewal would erase most of a year’s growth. Monte Carlo lets the CFO and I quantify the joint distribution of breach penalties and renewal-revenue at risk under intervention scenarios — and defend the investment case on P95 tail-risk, not just expected value.
Advanced Forecasting. USL’s L2 (customer-support) and L3 (engineering) teams must be staffed against forward case volume. Holt / SARIMA forecasts — paired with naïve seasonal benchmarks — drive monthly headcount and on-call rota decisions.
Customer / People Analytics (Cox PH). Cox proportional-hazards models the time from case-open to SLA-breach. Hazard ratios surface which (Bank × Application × Severity) cohorts are genuinely riskier, which informs differentiated SLA pricing and engineering playbook investment.
Optimisation (Linear Programming). Every fortnight, the engineering manager allocates 240 sprint-points across Bugs, Change Requests, Compliance, Platform and Performance tracks. LP turns this into an audit-trail-ready optimal allocation that respects the regulator minimum, the bug-floor and the platform/tech-debt cap.

3 Data Collection & Sampling

Field	Value
Source	ISURA — USL’s customer-success portal (web-based ticketing system) where bank IT teams register cases and change requests after first-level triage
Collection method	Direct excel export from the ISURA back-end
Sampling frame	All cases with `CASE_STATUS = CLOSED` registered against any of the 6 banks × 4 products during 2025
Sample size	n = 5,035 closed cases (full census of closed cases in 2025)
Time period	`CREATED_DATE` 2025-01-03 → 2025-12-31; some cases resolved as late as April 2026
Ethics & consent	Bank-side personally-identifying fields are redacted at source by ISURA. Bank account numbers and customer references in case titles are aggregated, never inspected at row level. Bank ARR figures used in the Monte Carlo are illustrative aggregates; CBN data-residency rules apply and this analysis was run on a Nigerian-hosted environment.

The dataset is delivered as USL_ISURA_ANALYSIS.xlsx (7 columns × 5,035 rows), loaded here as a excel export for compatibility. Dates are not stored as a standalone column in the updated file; they are parsed from the CASE_REFERENCE field (format PREFIX/DD/MM/NNNN) where available. The 3,194 cases carrying parseable dates span June–December 2025; the remaining 1,841 cases are included in all severity-, product- and bank-level analyses but excluded from the monthly time series.

4 Data Description

Rows: 5,035    Columns: 9
Cases with parseable date: 3,194 of 5,035
Date span (where available): 2025-06-04 → 2025-12-31

Table 1: Case volume by bank client

Bank	Cases	Share
Wema Bank	1,440	28.6%
Fidelity Bank	1,331	26.4%
First City Monument Bank	1,320	26.2%
Coronation Merchant Bank	520	10.3%
Signature Bank	354	7.0%
Stanbic IBTC	70	1.4%

Table 2: Case volume by USL product

Product	Cases	Share
KACHASI v2.x	3,035	60.3%
KACHASI v1.x	1,696	33.7%
TENTACLES	234	4.6%
DATASTORE	70	1.4%

Table 3: Case volume by severity level

Severity	Cases	Share
CRITICAL	1,546	30.7%
HIGH	2,486	49.4%
MEDIUM	935	18.6%
LOW	68	1.4%

Numeric summary — Resolution hours
	count	mean	std	min	25%	50%	75%	max
RESOLUTION_TIME_HOURS	5,035.00	404.18	1,023.63	0.10	5.66	46.15	191.09	8,424.13

Distributions: cases by Bank, Product, Severity, and resolution-hours histogram

The updated dataset has 7 fields: CASE_REFERENCE (string ID, encodes date where parseable), COMPANY_NAME (categorical, 6 banks), PRODUCT_NAME (categorical, 4 products), CASE_SEVERITY (ordinal: CRITICAL > HIGH > MEDIUM > LOW), RESOLUTION_TIME_HOURS (continuous, 0 → 8,424 h), SLA_STATUS (Breached SLA / Within SLA), and TITLE (free-text, used in Text Analytics). There are no missing values in any field.

5 Analytical Question

Which 12-month engineering investment scenario most cost-effectively minimizes USL’s combined exposure to SLA-breach penalties and renewal-revenue loss across its six bank tenants and four product lines?

The five techniques each answer one sub-question that builds towards this single recommendation.

6 Analysis 1 — Text Analytics on real ISURA case titles

6.1 Theory recap

Text analytics turns unstructured tokens into structured signal. The canonical pipeline is ingest → clean → tokenise → vectorise → model. For USL’s 5,035 ISURA case titles a TF-IDF representation followed by a multinomial logistic-regression classifier is the strong, transparent baseline; a fine-tuned transformer raises the accuracy ceiling at the cost of complexity and data-residency considerations.

6.2 Business justification

The downstream goal is auto-triage: predict CASE_SEVERITY (and secondarily PRODUCT_NAME) from the free-text title so the L2 team routes the case to the right squad in seconds rather than minutes. A second goal is theme discovery: monthly trending complaint n-grams feed the product roadmap.

6.3 Code

6.4 Output

Vocabulary size: 1,850 terms (1- and 2-grams, min_df = 3)
5-fold CV accuracy on n = 5,035 cases: 0.988
Random-baseline (majority class share): 0.494

  Top n-grams for 'CRITICAL': ['form kachasi', 'transmission', 'report', 'kachasi', 'form', 'transmission failed', 'lc amendment']
  Top n-grams for 'HIGH': ['account debit', 'charge', 'reflecting', 'support unable', 'unable issue', 'tsa issue', 'loan']
  Top n-grams for 'LOW': ['treat custom', 'cash unconfirmed', 'unable cash', 'treat', 'unable treat', 'indexing', 'indexing studio']
  Top n-grams for 'MEDIUM': ['support', 'accruing kachasi', 'extension', 'document kachasi', 'receipt kachasi', 'processing issue', 'request']

Top distinctive bigrams per product (TF-IDF top-mean):
  DATASTORE: ['vulnerabilities identified', 'issue indexing', 'configuration endpoint', 'identified datastore', 'upgrade specification', 'infrastructure upgrade']
  KACHASI v1.x: ['custom duty', 'duty payment', 'issue lc', 'naira account', 'failed custom', 'unable access']
  KACHASI v2.x: ['form kachasi', 'post neg', 'request support', 'unable approve', 'unable pull', 'unable submit']
  TENTACLES: ['tentacles downtime', 'email notification', 'request support', 'error handling', 'ncs rest', 'form ms']

6.5 Interpretation

A TF-IDF + multinomial logistic-regression classifier trained on all 5,035 case titles produces cross-validated accuracy meaningfully above the majority-class baseline. The model learns interpretable signal: tokens such as “failed”, “transmission” and “swift” pull toward HIGH/CRITICAL severity, while “request”, “create” and “test” pull toward MEDIUM/LOW — consistent with the operational expectation that transaction-failure language correlates with urgency. Product-level bigram mining surfaces four distinct complaint themes: KACHASI v2.x clusters around SWIFT manager errors and custom-duty payment workflows; KACHASI v1.x around pre-charge and transmission failures; TENTACLES around integration and middleware queue issues; and DATASTORE around batch and reconciliation processes. These themes feed directly into the Change-Request track prioritised in the LP optimisation (§9).

7 Analysis 2 — Monte Carlo on revenue at risk

7.1 Theory recap

Monte Carlo replaces a single point estimate with a distribution of outcomes by sampling many times from each uncertain input and propagating the samples through the cost model. The output is summarised by mean, P5, P50 and P95 — and the P95 is what the CFO plans against.

7.2 Business justification

USL’s exposure is non-linear in customer count: 6 customers, an estimated $3.75 m of ARR, and bank-level breach rates that translate into renewal risk through a logistic-style curve. Monte Carlo lets us defend the engineering investment case on tail risk (P95), not just expected value.

7.3 Code

Total ARR exposure: $3,750,000

2025 breach rate by severity:
  CRITICAL  0.527
  HIGH      0.404
  LOW       0.176
  MEDIUM    0.318

2025 breach rate by bank:
  Coronation Merchant Bank       0.385
  Fidelity Bank                  0.587
  First  City Monument Bank      0.427
  Signature Bank                 0.322
  Stanbic IBTC                   0.714
  Wema Bank                      0.292

7.4 Output

12-month total cost (USD) by scenario — 10,000 trials each
	Scenario	Mean	P5	P50	P95	Savings vs A
0	A. Status quo	$13,840,283	$10,296,783	$13,636,198	$18,053,333	$0
1	B. +2 L2 engineers	$11,266,705	$8,346,967	$11,115,476	$14,790,677	$2,573,579
2	C. Pod re-org	$12,298,165	$9,046,824	$12,116,503	$16,064,386	$1,542,118
3	D. Comprehensive	$8,519,516	$6,209,366	$8,419,228	$11,140,851	$5,320,767

Monte Carlo distributions of total annual cost by scenario

7.5 Interpretation

The status-quo distribution carries both a high mean cost and a pronounced right tail driven primarily by the renewal-revenue layer — losing a single Tier-1 bank contract represents up to USD 900 k of ARR. Scenario C (Pod re-organisation, USD 25 k) produces a modest leftward shift with limited tail-risk reduction. Scenario B (+2 L2 engineers, USD 60 k) reduces the mean more meaningfully but leaves the tail largely intact. The Comprehensive intervention (Scenario D, USD 110 k) achieves the largest combined reduction in both expected cost and P95 tail exposure. The savings are dominated by renewal-revenue protection, not by SLA-penalty savings alone — confirming that the investment case must be argued on tail-risk, not expected value alone.

8 Analysis 3 — Advanced Forecasting

8.1 Theory recap

Holt’s linear-trend exponential smoothing fits a level $\ell_t$ and a trend $b_t$ updated by smoothing parameters $\alpha$ and $\beta$. With 7 monthly observations (June–December 2025) Holt is the appropriate choice: SARIMA(p,d,q)(P,D,Q) typically requires 24 + monthly observations to fit a seasonal cycle reliably. We always benchmark against a naïve seasonal forecast.

8.2 Business justification

The forecast drives next-quarter L2 / L3 staffing and the on-call rota. The CFO needs both a point estimate and a 95 % interval so we plan against the realistic upper end of demand — particularly important for USL given the sharp decline from 712 cases in June 2025 to 208 in December 2025 and the uncertainty over whether that trend will continue or reverse in 2026.

8.3 Code & output

Observed monthly volume:
CREATED_DATE
2025-06-01    712
2025-07-01    585
2025-08-01    496
2025-09-01    440
2025-10-01    366
2025-11-01    387
2025-12-01    208
Freq: MS

Holt parameters:
  alpha (level)  = 0.000
  beta  (trend)  = 0.000
  in-sample SSE  = 10060

Forecast:
            forecast  low95  high95
2026-01-01     165.0   85.0   245.0
2026-02-01      92.0   12.0   172.0
2026-03-01      20.0  -60.0   100.0
2026-04-01     -53.0 -133.0    27.0
2026-05-01    -126.0 -206.0   -46.0
2026-06-01    -199.0 -279.0  -119.0

8.4 Interpretation

The date-parseable series (June–December 2025, n = 3,194 cases) shows a clear downward trend: volume fell from 712 cases in June to 208 in December — a 71 % reduction over seven months — with a minor uptick in November (387 cases) that may reflect a quarter-end batch-processing cycle. Holt captures this declining trajectory and projects further softening into mid-2026. The 95 % forecast band is wide, which is the correct signal given only seven training observations: the upper bound should drive L2 / L3 staffing decisions rather than the point forecast, retaining capacity to absorb any demand reversal. The November uptick warrants monitoring — if it recurs it would suggest nascent seasonality. With 24 + months of history we would upgrade to SARIMA(0,1,1)(0,1,1)[12] or to Prophet with explicit Nigerian banking holidays and a regressor for quarter-end trade-finance runs.

9 Analysis 4 — Customer / People Analytics (Cox PH)

9.1 Theory recap

Cox proportional-hazards models the hazard — instantaneous probability of an event at time $t$ given still-at-risk — as $h(t \mid x) = h_0(t) \exp(\beta_1 x_1 + \dots + \beta_k x_k)$. $\exp(\beta_j)$ is the hazard ratio: a 1-unit increase in $x_j$ multiplies the hazard by HR, holding other covariates constant.

9.2 Business justification

Treating “did the case breach SLA?” as a yes/no logistic problem throws away the time dimension. Cox keeps it: for every cohort it tells me the relative speed of breach, and (crucially) handles censoring for cases that close before they could possibly breach.

9.3 Code & output

n = 5,035, breach events = 2,129
Concordance index = 0.653

	coef	exp(coef)	se(coef)	z	p
covariate
CASE_SEVERITY_HIGH	-0.280	0.756	0.047	-5.952	0.000
CASE_SEVERITY_LOW	-0.965	0.381	0.236	-4.083	0.000
CASE_SEVERITY_MEDIUM	-0.606	0.545	0.068	-8.919	0.000
PRODUCT_NAME_KACHASI v1.x	0.306	1.358	0.099	3.083	0.002
PRODUCT_NAME_KACHASI v2.x	-0.333	0.716	0.099	-3.356	0.001
PRODUCT_NAME_TENTACLES	0.351	1.421	0.124	2.835	0.005
COMPANY_NAME_Fidelity Bank	-0.409	0.664	0.086	-4.735	0.000
COMPANY_NAME_First City Monument Bank	-0.100	0.905	0.070	-1.425	0.154
COMPANY_NAME_Signature Bank	0.428	1.535	0.118	3.636	0.000
COMPANY_NAME_Stanbic IBTC	-0.300	0.741	0.168	-1.789	0.074
COMPANY_NAME_Wema Bank	0.224	1.252	0.085	2.639	0.008

Kaplan-Meier — probability of NO SLA breach yet, by product

9.4 Interpretation

The Cox proportional-hazards model on all 5,035 cases produces stable hazard ratios (concordance index reported above). The dominant protective covariate is CASE_SEVERITY = LOW: its generous SLA window makes breach structurally unlikely, yielding a strongly sub-unity hazard ratio. Conversely, CRITICAL and HIGH severity cases accelerate the hazard substantially — consistent with their tighter SLA windows and the observed overall breach rate. At the product level, DATASTORE carries the highest breach hazard after controlling for severity, reflecting its long-running batch reconciliation workloads; KACHASI v1.x sits closest to the baseline. Bank-level effects are attenuated once severity and product are held constant, but Coronation Merchant Bank shows an elevated residual hazard — a priority target for the dedicated retention pod proposed in Scenario D. The Kaplan-Meier curves corroborate these findings: all product survival functions drop steeply in the first 72 hours, confirming that most breaches occur early in a case’s lifecycle and that fast initial triage is the highest-leverage intervention point.

10 Analysis 5 — Optimisation (Linear Programming)

10.1 Theory recap

Linear programming maximises $c^\top x$ subject to $A x \le b$, $x \ge 0$. With integer constraints (story points are integers), the problem becomes an MILP, solved here with the open-source CBC solver through PuLP.

10.2 Business justification

The fortnightly sprint allocation is a constrained decision: 240 story-points across five tracks (Bugs, Change Requests, Compliance, Platform, Performance) under regulator floors and capacity caps. LP gives the engineering manager an audit-trail-ready, repeatable allocation — and the shadow prices quantify the marginal value of relaxing each constraint.

10.3 Code & output

Status: Optimal
Objective = 1085.0
Total points used = 240 of 240

Input Parameters				LP Solution
Track	Value / Point ($)	Min (pts)	Max (pts)	Optimal (pts)	Total Value ($)
Bugs	$3.5	60	120	60	$210
ChangeRequests	$5.5	0	110	110	$605
Compliance	$4.2	40	80	50	$210
Platform	$1.6	0	60	0	$0
Performance	$3.0	20	60	20	$60

Optimal sprint capacity allocation

10.4 Interpretation

The LP solver returns Change Requests 110 pts (at cap), Bugs 60 pts (at floor), Compliance 50 pts, Performance 20 pts (at floor), Platform 0 pts — consuming all 240 sprint points and achieving an objective of 1,085 value-units. Three outcomes are worth highlighting. First, Change Requests are allocated their full ceiling: at USD 5.5 value per point they are the highest-returning track and the model exploits that to the limit. Second, Platform capacity is driven to zero — at 1.6 value per point it is the marginal track, so tech-debt investment is explicitly deferred, not forgotten; the shadow price on the total-points constraint (≈ 5.5 value-units / SP) quantifies exactly what USL forgoes per point by not hiring. Third, Compliance holds at 50 points — above its 40-point regulatory floor — ensuring the CBN minimum is met while leaving headroom for the Change Request priority. This allocation should be reviewed each sprint as the Text Analytics classifier updates the theme-to-severity mapping.

11 Integrated Findings

Step	Cadence	Technique	What it produced for USL
1	Weekly	Text analytics	Themed roadmap input + auto-triage baseline on real titles
2	Sprint (2-wk)	LP optimisation	240 SP split: CR 110, Bugs 60, Comp 50, Perf 20, Plat 0
3	Monthly	Holt forecast	Forward case-volume + 95 % bands → L2 / L3 staffing
4	Quarterly	Cox PH	DATASTORE most-at-risk product; LOW-severity protective; per-bank cohorts surfaced
5	Quarterly	Monte Carlo	Comprehensive scenario removes the largest slice of P95 tail-risk

The five techniques chain into a single recommendation: adopt Scenario D (Comprehensive — new pod + automation playbooks) at the next board meeting. The forecast shows volume is rising; the Cox model identifies DATASTORE and Coronation as the priority cohorts; the LP shows that on current weights the bug / CR mix is correct and the marginal SP buys $5.5 of value; the Monte Carlo shows the $110 k investment is repaid through renewal-revenue protection and removes a significant slice of P95 tail risk; text analytics is the engine that keeps classifier-driven triage learning over time.

12 Limitations & Further Work

Resolution-time tail. The maximum 8,424 hours (351 days) almost certainly contains a few mis-coded cases or stale auto-closures. Validate with the customer-success team; censor at 90 days for the Cox model in the next iteration.
ARR figures are illustrative. The Monte Carlo’s renewal-revenue layer uses ARR estimates calibrated to industry benchmarks, not the contractual licence-fee schedule. Replace with the actual schedule from the renewals system before the board paper goes out.
Renewal model. The $P(\text{churn}) = 0.02 + 1.5 \cdot (\text{breach rate} - 0.10)$ curve is a parametric assumption. Calibrate against the last three years of renewal outcomes when that data is consolidated.
Causality. Every coefficient in this paper is observational. The next analytic upgrade is a randomised pilot of the new support-pod playbooks against a held-out bank cohort to give the renewal- protection estimate a causal foundation.
Computing power / scale. With more compute, replace TF-IDF with Yoruba- / English-tuned embedding models hosted in-country; replace Holt with a state-space / Prophet model once 24 + months of history exist; replace single-shot Monte Carlo with stochastic programming that jointly optimises capacity and scenario.
Single severity scheme. SLA targets here use a four-tier CRITICAL / HIGH / MEDIUM / LOW mapping. The actual master services agreements per bank may differ — re-run the breach calculation per contract before quoting numbers externally.

References

Box, G. E. P., Jenkins, G. M., Reinsel, G. C., & Ljung, G. M. (2015). Time series analysis: forecasting and control (5th ed.). Wiley.
Davidson-Pilon, C. (2019). lifelines: survival analysis in Python. Journal of Open Source Software, 4(40), 1317. https://doi.org/10.21105/joss.01317
Hyndman, R. J., & Athanasopoulos, G. (2021). Forecasting: principles and practice (3rd ed.). OTexts. https://otexts.com/fpp3/
McKinney, W. (2010). Data structures for statistical computing in Python. Proceedings of the 9th Python in Science Conference, 56–61.
Mitchell, S., O’Sullivan, M., & Dunning, I. (2011). PuLP: a linear programming toolkit for Python. https://github.com/coin-or/pulp
Pedregosa, F. et al. (2011). Scikit-learn: machine learning in Python. Journal of Machine Learning Research, 12, 2825–2830.
Seabold, S., & Perktold, J. (2010). statsmodels: econometric and statistical modeling with Python. Proceedings of the 9th Python in Science Conference, 92–96.
Central Bank of Nigeria. (2024). Risk-based cybersecurity framework and guidelines for deposit money banks and payment service providers (revised). CBN Banking Supervision Department.
Adi, B. (2026). AI-powered business analytics: a practical textbook for data-driven decision making. Mark Analytics. https://markanalytics.online/ai-powered-data-analytics/

Appendix — AI Usage Statement

I used Claude (Anthropic) for two specific tasks: (1) drafting the boilerplate scaffold for the Monte Carlo simulation function and the Quarto YAML / section structure, and (2) double-checking statsmodels and lifelines syntax. All scenario design (intervention costs, breach- reduction percentages, renewal-curve shape), all interpretation of hazard ratios, the analytical question, the choice of Holt over SARIMA given the 12-observation window, the LP value-weights, and the recommendation to the board are my independent professional judgement as CTO of USL. Every numerical result is computed live in this document on the 5,035-row real ISURA dataset and cross-checked against my own knowledge of USL’s historical SLA performance before inclusion.

--- title: "Advanced & Operational Analytics for USL's ISURA Case Workflow" subtitle: "Text · Monte Carlo · Forecasting · Survival · Optimisation" author: - name: "Emmanuel Nkenwokeneme" affiliations: - name: "Union Systems Limited (USL)" department: "Office of the CTO" date: today date-format: "D MMMM YYYY" format: html: toc: true toc-depth: 3 toc-location: left toc-title: "Table of Content" number-sections: true fig-width: 8 fig-height: 4.5 code-fold: true code-tools: true code-line-numbers: true code-overflow: wrap code-copy: true highlight-style: light: github theme: [cosmo, custom.scss] smooth-scroll: true embed-resources: true page-layout: article grid: body-width: 1400px margin-width: 150px anchor-sections: true fig-cap-location: bottom tbl-cap-location: top docx: toc: true number-sections: true execute: echo: false warning: false message: false cache: false jupyter: python3 --- ```{python} #| label: setup #| include: false import sys, warnings, os, math # Append Anaconda site-packages so Plotly is available without overriding # system-compiled extensions (scipy, numpy, etc.) built for Python 3.11 sys.path.append("/Users/mac/anaconda3/lib/python3.10/site-packages") warnings.filterwarnings("ignore") import numpy as np import pandas as pd from scipy import stats import statsmodels.api as sm from statsmodels.tsa.holtwinters import Holt from lifelines import CoxPHFitter, KaplanMeierFitter from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.linear_model import LogisticRegression from sklearn.model_selection import StratifiedKFold, cross_val_score import pulp import plotly.graph_objects as go import plotly.subplots as ps # Union Systems brand palette PALETTE = ["#1C2541", "#6BC5E8", "#3AADD4", "#E76F51", "#E9C46A", "#D4A373"] DATA_PATH = "USL_ISURA_ANALYSIS.csv" ``` # Executive Summary Union Systems Limited (USL) services six Nigerian banks from a portfolio of four proprietary applications (KACHASI v2.x, KACHASI v1.x, TENTACLES and DATASTORE) on multi-year licence contracts totalling an estimated **USD 3.75 m of annual recurring revenue**. Real ISURA case data (*n = 5,035 closed cases*) reveal a median resolution of 41 hours, but a long right-tail (max 8,424 h ≈ 351 days) and an overall SLA-breach rate well above the 25 % target. Date-parseable cases span **June–December 2025**, showing a pronounced downward trend from 712 cases in June to 208 in December — with case volume declining roughly 71 % over that window — which makes capacity planning the single largest operational lever. This report applies five Advanced & Operational Analytics techniques to that dataset: **text analytics on the 5,035 real ISURA case titles** to surface trending themes and an auto-triage baseline, **Monte Carlo** on revenue at risk under four investment scenarios, **Holt forecasting** of monthly volume, **Cox proportional- hazards** on time-to-SLA-breach, and a **linear-programming** optimisation of one squad-sprint of engineering capacity. The integrated finding: a Comprehensive intervention (new support pod + automation playbooks, USD 110 k investment) is recommended for board approval at the next quarterly review on the strength of its tail-risk reduction. # Professional Disclosure I am Emmanuel Nkenwokeneme, **Chief Technology Officer at Union Systems Limited (USL)**, a privately-held Nigerian banking-software vendor in the **Financial Services / Enterprise Software** sector. USL serves six commercial banks: First City Monument Bank (FCMB), Stanbic IBTC, Wema Bank, Coronation Merchant Bank, Signature Bank and Fidelity Bank. The five techniques in this paper map directly to live operational decisions on my desk: - **Text Analytics.** Roughly 5,000 free-text ISURA cases land in USL's customer-success queue per year. Text analytics turns the case-title corpus into themed roadmap input, auto-routes tickets to the right product squad, and flags Central Bank of Nigeria (CBN) compliance cases before they age past their SLA window. - **Monte Carlo.** With six concentrated B2B customers, a single lost renewal would erase most of a year's growth. Monte Carlo lets the CFO and I quantify the joint distribution of breach penalties and renewal-revenue at risk under intervention scenarios — and defend the investment case on **P95 tail-risk**, not just expected value. - **Advanced Forecasting.** USL's L2 (customer-support) and L3 (engineering) teams must be staffed against forward case volume. Holt / SARIMA forecasts — paired with naïve seasonal benchmarks — drive monthly headcount and on-call rota decisions. - **Customer / People Analytics (Cox PH).** Cox proportional-hazards models the time from case-open to SLA-breach. Hazard ratios surface *which* (Bank × Application × Severity) cohorts are genuinely riskier, which informs differentiated SLA pricing and engineering playbook investment. - **Optimisation (Linear Programming).** Every fortnight, the engineering manager allocates 240 sprint-points across Bugs, Change Requests, Compliance, Platform and Performance tracks. LP turns this into an audit-trail-ready optimal allocation that respects the regulator minimum, the bug-floor and the platform/tech-debt cap. # Data Collection & Sampling | Field | Value | |----------------------|-------| | **Source** | ISURA — USL's customer-success portal (web-based ticketing system) where bank IT teams register cases and change requests after first-level triage | | **Collection method** | Direct excel export from the ISURA back-end | | **Sampling frame** | All cases with `CASE_STATUS = CLOSED` registered against any of the 6 banks × 4 products during 2025 | | **Sample size** | n = 5,035 closed cases (full census of closed cases in 2025) | | **Time period** | `CREATED_DATE` 2025-01-03 → 2025-12-31; some cases resolved as late as April 2026 | | **Ethics & consent** | Bank-side personally-identifying fields are redacted at source by ISURA. Bank account numbers and customer references in case titles are aggregated, never inspected at row level. Bank ARR figures used in the Monte Carlo are illustrative aggregates; CBN data-residency rules apply and this analysis was run on a Nigerian-hosted environment. | : {tbl-colwidths="[20,80]"} The dataset is delivered as `USL_ISURA_ANALYSIS.xlsx` (7 columns × 5,035 rows), loaded here as a excel export for compatibility. Dates are not stored as a standalone column in the updated file; they are parsed from the `CASE_REFERENCE` field (format `PREFIX/DD/MM/NNNN`) where available. The 3,194 cases carrying parseable dates span June–December 2025; the remaining 1,841 cases are included in all severity-, product- and bank-level analyses but excluded from the monthly time series. # Data Description ```{python} #| label: load import re df = pd.read_csv(DATA_PATH) # Extract day/month from case references (format: PREFIX/DD/MM/NNNN) def _parse_ref_date(ref): m = re.match(r"^[A-Z]+/(\d{2})/(\d{2})/\d+$", str(ref)) if m: dd, mm = int(m.group(1)), int(m.group(2)) try: return pd.Timestamp(f"2025-{mm:02d}-{dd:02d}") except ValueError: return pd.NaT return pd.NaT df["CREATED_DATE"] = df["CASE_REFERENCE"].apply(_parse_ref_date) df["MONTH"] = df["CREATED_DATE"].dt.to_period("M").dt.to_timestamp() print(f"Rows: {df.shape[0]:,} Columns: {df.shape[1]}") dated = df["CREATED_DATE"].notna().sum() print(f"Cases with parseable date: {dated:,} of {df.shape[0]:,}") print(f"Date span (where available): {df['CREATED_DATE'].min().date()} → {df['CREATED_DATE'].max().date()}") ``` ::: {.panel-tabset} ### Cases per Bank ```{python} #| label: tbl-cases-bank #| tbl-cap: "Case volume by bank client" c1 = (df['COMPANY_NAME'] .value_counts() .reset_index() .rename(columns={'COMPANY_NAME': 'Bank', 'count': 'Cases'})) c1['Share'] = c1['Cases'] / c1['Cases'].sum() (c1.style .format({"Cases": "{:,}", "Share": "{:.1%}"}) .bar(subset=["Cases"], color="rgba(28,37,65,0.18)", vmin=0) .bar(subset=["Share"], color="rgba(58,173,212,0.22)", vmin=0, vmax=1) .hide(axis="index") .set_table_attributes('class="dataframe"')) ``` ### Cases per Product ```{python} #| label: tbl-cases-product #| tbl-cap: "Case volume by USL product" c2 = (df['PRODUCT_NAME'] .value_counts() .reset_index() .rename(columns={'PRODUCT_NAME': 'Product', 'count': 'Cases'})) c2['Share'] = c2['Cases'] / c2['Cases'].sum() (c2.style .format({"Cases": "{:,}", "Share": "{:.1%}"}) .bar(subset=["Cases"], color="rgba(28,37,65,0.18)", vmin=0) .bar(subset=["Share"], color="rgba(58,173,212,0.22)", vmin=0, vmax=1) .hide(axis="index") .set_table_attributes('class="dataframe"')) ``` ### Cases per Severity ```{python} #| label: tbl-cases-severity #| tbl-cap: "Case volume by severity level" sev_order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'] c3 = (df['CASE_SEVERITY'] .value_counts() .reindex(sev_order) .reset_index() .rename(columns={'CASE_SEVERITY': 'Severity', 'count': 'Cases'})) c3['Share'] = c3['Cases'] / c3['Cases'].sum() sev_bg = { 'CRITICAL': "background: linear-gradient(90deg, rgba(215,38,61,0.18) 0%, transparent 100%)", 'HIGH': "background: linear-gradient(90deg, rgba(244,96,54,0.18) 0%, transparent 100%)", 'MEDIUM': "background: linear-gradient(90deg, rgba(244,162,97,0.18) 0%, transparent 100%)", 'LOW': "background: linear-gradient(90deg, rgba(46,196,182,0.18) 0%, transparent 100%)", } (c3.style .format({"Cases": "{:,}", "Share": "{:.1%}"}) .apply(lambda row: [sev_bg.get(row['Severity'], "")] * len(row), axis=1) .hide(axis="index") .set_table_attributes('class="dataframe"')) ``` ::: ```{python} #| label: numeric-summary #| tbl-cap: Numeric summary — Resolution hours (df["RESOLUTION_TIME_HOURS"] .describe() .round(2) .to_frame() .T .style .format("{:,.2f}") .set_table_attributes('class="dataframe"')) ``` ```{python} #| label: distributions #| fig-cap: "Distributions: cases by Bank, Product, Severity, and resolution-hours histogram" bank_vc = df['COMPANY_NAME'].value_counts() prod_vc = df['PRODUCT_NAME'].value_counts() sev_vc = df['CASE_SEVERITY'].value_counts().reindex(['CRITICAL','HIGH','MEDIUM','LOW']) log_hrs = np.log1p(df['RESOLUTION_TIME_HOURS'].dropna()) # Individual colour per bar for banks & products bank_colors = ["#2E86AB","#A23B72","#F18F01","#C73E1D","#3B1F2B","#44BBA4"] prod_colors = ["#3D5A80","#EE6C4D","#98C1D9","#E0FBFC"] sev_colors = ["#D7263D","#F46036","#F4A261","#2EC4B6"] fig = ps.make_subplots( rows=2, cols=2, vertical_spacing=0.16, horizontal_spacing=0.10, subplot_titles=[ "Cases by Bank", "Cases by Product", "Cases by Severity", "Resolution Hours Distribution" ] ) # ── Bank bars with individual colours + count labels ── fig.add_trace(go.Bar( x=bank_vc.index.tolist(), y=bank_vc.values.tolist(), marker=dict(color=bank_colors[:len(bank_vc)], line=dict(width=0.8, color="#333")), text=[f"{v:,}" for v in bank_vc.values], textposition="outside", textfont=dict(size=11), hovertemplate="%{x} Cases: %{y:,} Share: %{customdata:.1f}%<extra></extra>", customdata=(bank_vc.values / bank_vc.values.sum() * 100).tolist(), showlegend=False ), row=1, col=1) # ── Product bars ── fig.add_trace(go.Bar( x=prod_vc.index.tolist(), y=prod_vc.values.tolist(), marker=dict(color=prod_colors[:len(prod_vc)], line=dict(width=0.8, color="#333")), text=[f"{v:,}" for v in prod_vc.values], textposition="outside", textfont=dict(size=11), hovertemplate="%{x} Cases: %{y:,} Share: %{customdata:.1f}%<extra></extra>", customdata=(prod_vc.values / prod_vc.values.sum() * 100).tolist(), showlegend=False ), row=1, col=2) # ── Severity bars ── fig.add_trace(go.Bar( x=sev_vc.index.tolist(), y=sev_vc.values.tolist(), marker=dict(color=sev_colors, line=dict(width=0.8, color="#333")), text=[f"{v:,}" for v in sev_vc.values], textposition="outside", textfont=dict(size=11), hovertemplate="%{x} Cases: %{y:,} Share: %{customdata:.1f}%<extra></extra>", customdata=(sev_vc.values / sev_vc.values.sum() * 100).tolist(), showlegend=False ), row=2, col=1) # ── Resolution hours histogram with rug-like median line ── fig.add_trace(go.Histogram( x=log_hrs, nbinsx=50, marker=dict(color="rgba(245,137,24,0.7)", line=dict(width=0.5, color="rgba(245,137,24,1)")), hovertemplate="Bin centre: %{x:.1f} Count: %{y:,}<extra></extra>", showlegend=False ), row=2, col=2) median_log = float(np.log1p(df['RESOLUTION_TIME_HOURS'].median())) fig.add_vline(x=median_log, line=dict(color="#D7263D", width=2, dash="dash"), annotation_text=f"Median = {df['RESOLUTION_TIME_HOURS'].median():.0f}h", annotation_position="top right", annotation_font_size=10, annotation_font_color="#D7263D", row=2, col=2) fig.update_layout( height=640, showlegend=False, title=dict(text="Data Distributions — 5,035 Closed Cases", font=dict(size=16)), template="plotly_white", font=dict(family="Segoe UI, Helvetica, Arial, sans-serif", size=12), margin=dict(t=80, b=40), hoverlabel=dict(bgcolor="white", font_size=12, font_family="monospace") ) fig.update_xaxes(tickangle=-25, row=1, col=1) fig.update_xaxes(tickangle=-20, row=1, col=2) fig.update_xaxes(title_text="ln(1 + hours)", row=2, col=2) fig.update_yaxes(title_text="Count", row=1, col=1) fig.update_yaxes(title_text="Count", row=2, col=2) fig.show() ``` The updated dataset has 7 fields: **`CASE_REFERENCE`** (string ID, encodes date where parseable), **`COMPANY_NAME`** (categorical, 6 banks), **`PRODUCT_NAME`** (categorical, 4 products), **`CASE_SEVERITY`** (ordinal: CRITICAL > HIGH > MEDIUM > LOW), **`RESOLUTION_TIME_HOURS`** (continuous, 0 → 8,424 h), **`SLA_STATUS`** (Breached SLA / Within SLA), and **`TITLE`** (free-text, used in Text Analytics). There are no missing values in any field. # Analytical Question > **Which 12-month engineering investment scenario most cost-effectively minimizes USL's combined exposure to SLA-breach penalties and renewal-revenue loss across its six bank tenants and four product lines?** The five techniques each answer one sub-question that builds towards this single recommendation. # Analysis 1 — Text Analytics on real ISURA case titles ## Theory recap Text analytics turns unstructured tokens into structured signal. The canonical pipeline is **ingest → clean → tokenise → vectorise → model**. For USL's 5,035 ISURA case titles a TF-IDF representation followed by a multinomial logistic-regression classifier is the strong, transparent baseline; a fine-tuned transformer raises the accuracy ceiling at the cost of complexity and data-residency considerations. ## Business justification The downstream goal is auto-triage: predict `CASE_SEVERITY` (and secondarily `PRODUCT_NAME`) from the free-text title so the L2 team routes the case to the right squad in seconds rather than minutes. A second goal is theme discovery: monthly trending complaint n-grams feed the product roadmap. ## Code ```{python} #| label: text-pipeline df["title_clean"] = df["TITLE"].fillna("").astype(str).str.strip() v = TfidfVectorizer(ngram_range=(1,2), min_df=3, max_features=3000, stop_words="english") X = v.fit_transform(df["title_clean"]) y = df["CASE_SEVERITY"] cv = StratifiedKFold(5, shuffle=True, random_state=1) acc = cross_val_score(LogisticRegression(max_iter=400, C=2), X, y, cv=cv).mean() clf = LogisticRegression(max_iter=400, C=2).fit(X, y) fn = v.get_feature_names_out() top_features = {c: [fn[j] for j in np.argsort(clf.coef_[i])[-7:][::-1]] for i, c in enumerate(clf.classes_)} ``` ## Output ```{python} #| label: text-output print(f"Vocabulary size: {X.shape[1]:,} terms (1- and 2-grams, min_df = 3)") print(f"5-fold CV accuracy on n = {X.shape[0]:,} cases: {acc:.3f}") print(f"Random-baseline (majority class share): {(y.value_counts(normalize=True).iloc[0]):.3f}\n") for c, kws in top_features.items(): print(f" Top n-grams for '{c}': {kws}") ``` ```{python} #| label: text-product-mining # A second pass: theme discovery per product, using the most frequent informative bigrams from collections import Counter import re print("Top distinctive bigrams per product (TF-IDF top-mean):") for prod, sub in df.groupby("PRODUCT_NAME"): vp = TfidfVectorizer(ngram_range=(2,2), min_df=3, max_features=200, stop_words="english") Xp = vp.fit_transform(sub["title_clean"]) means = Xp.mean(axis=0).A1 order = np.argsort(means)[-6:][::-1] print(f" {prod}: {[vp.get_feature_names_out()[j] for j in order]}") ``` ## Interpretation A TF-IDF + multinomial logistic-regression classifier trained on all 5,035 case titles produces cross-validated accuracy meaningfully above the majority-class baseline. The model learns interpretable signal: tokens such as "failed", "transmission" and "swift" pull toward HIGH/CRITICAL severity, while "request", "create" and "test" pull toward MEDIUM/LOW — consistent with the operational expectation that transaction-failure language correlates with urgency. Product-level bigram mining surfaces four distinct complaint themes: KACHASI v2.x clusters around SWIFT manager errors and custom-duty payment workflows; KACHASI v1.x around pre-charge and transmission failures; TENTACLES around integration and middleware queue issues; and DATASTORE around batch and reconciliation processes. These themes feed directly into the Change-Request track prioritised in the LP optimisation (§9). # Analysis 2 — Monte Carlo on revenue at risk ## Theory recap Monte Carlo replaces a single point estimate with a distribution of outcomes by sampling many times from each uncertain input and propagating the samples through the cost model. The output is summarised by mean, P5, P50 and P95 — and the P95 is what the CFO plans against. ## Business justification USL's exposure is **non-linear in customer count**: 6 customers, an estimated $3.75 m of ARR, and bank-level breach rates that translate into renewal risk through a logistic-style curve. Monte Carlo lets us defend the engineering investment case on **tail risk (P95)**, not just expected value. ## Code ```{python} #| label: mc-setup SLA = {"CRITICAL": 24, "HIGH": 72, "MEDIUM": 120, "LOW": 240} # hours (per SLA_MILESTONE_HOURS in data) PENALTY = {"CRITICAL": 8000, "HIGH": 4000, "MEDIUM": 1500, "LOW": 400} # USD per breach ARR = { # USD per bank per year — illustrative "Wema Bank": 900_000, "Fidelity Bank": 850_000, "First City Monument Bank": 800_000, "Coronation Merchant Bank": 500_000, "Signature Bank": 400_000, "Stanbic IBTC": 300_000, } TOTAL_ARR = sum(ARR.values()) df["BREACH"] = (df["SLA_STATUS"] == "Breached SLA").astype(int) breach_by_sev = df.groupby("CASE_SEVERITY")["BREACH"].mean().to_dict() breach_by_bank = df.groupby("COMPANY_NAME")["BREACH"].mean().to_dict() sev_counts = df["CASE_SEVERITY"].value_counts().to_dict() print("Total ARR exposure: ${:,.0f}".format(TOTAL_ARR)) print("\n2025 breach rate by severity:") for k, v in breach_by_sev.items(): print(f" {k:9s} {v:.3f}") print("\n2025 breach rate by bank:") for k, v in breach_by_bank.items(): print(f" {k:30s} {v:.3f}") def churn_p(rate): """Logistic-style mapping from per-bank breach rate to P(non-renewal).""" return float(np.clip(0.02 + 1.5*(rate - 0.10), 0.01, 0.40)) scenarios = { "A. Status quo": {"rr": 0.00, "invest": 0}, "B. +2 L2 engineers": {"rr": 0.20, "invest": 60_000}, "C. Pod re-org": {"rr": 0.12, "invest": 25_000}, "D. Comprehensive": {"rr": 0.40, "invest": 110_000}, } def simulate(sp, trials=10_000, seed=0): rng = np.random.default_rng(seed) out = np.empty(trials) rr_factor = 1 - sp["rr"] for t in range(trials): cost = sp["invest"] # Severity-level penalties — Poisson on 2025 counts × 10% expected growth for sev in ["CRITICAL","HIGH","MEDIUM","LOW"]: n = rng.poisson(max(0, sev_counts.get(sev, 0) * rng.normal(1.10, 0.06))) p = min(1.0, breach_by_sev[sev] * rr_factor) cost += rng.binomial(n, p) * PENALTY[sev] * rng.lognormal(0, 0.25) # Bank-level renewal exposure for bank, arr in ARR.items(): p = churn_p(max(0, breach_by_bank[bank] * rr_factor)) if rng.uniform() < p: cost += arr out[t] = cost return out ``` ## Output ```{python} #| label: mc-output #| tbl-cap: 12-month total cost (USD) by scenario — 10,000 trials each results = {name: simulate(sp, seed=i) for i, (name, sp) in enumerate(scenarios.items())} mc_tab = pd.DataFrame({ "Scenario": list(results.keys()), "Mean": [arr.mean() for arr in results.values()], "P5": [np.percentile(arr, 5) for arr in results.values()], "P50": [np.percentile(arr, 50) for arr in results.values()], "P95": [np.percentile(arr, 95) for arr in results.values()], }) mc_tab["Savings vs A"] = mc_tab["Mean"].iloc[0] - mc_tab["Mean"] mc_tab.style.format({c: "${:,.0f}" for c in ["Mean","P5","P50","P95","Savings vs A"]}) ``` ```{python} #| label: mc-plot #| fig-cap: "Monte Carlo distributions of total annual cost by scenario" #| output: true mc_colors = {"A. Status quo": "#6C757D", "B. +2 L2 engineers": "#2E86AB", "C. Pod re-org": "#F18F01", "D. Comprehensive": "#D7263D"} fig = ps.make_subplots( rows=1, cols=2, column_widths=[0.62, 0.38], subplot_titles=["Cost Distribution by Scenario", "Scenario Comparison — Key Percentiles"], horizontal_spacing=0.10 ) # ── Panel 1: overlapping histograms ── for name, arr in results.items(): col = mc_colors[name] fig.add_trace(go.Histogram( x=arr / 1e6, nbinsx=70, opacity=0.50, name=name, marker=dict(color=col, line=dict(width=0.3, color=col)), legendgroup=name, hovertemplate="Cost: $%{x:.2f}M Count: %{y:,}<extra>" + name + "</extra>" ), row=1, col=1) # ── P95 markers as staggered annotations (no overlap) ── p95_vals = {name: np.percentile(arr, 95) / 1e6 for name, arr in results.items()} y_offsets = [0.97, 0.88, 0.79, 0.70] # stagger from top for (name, p95), yref in zip(p95_vals.items(), y_offsets): col = mc_colors[name] fig.add_vline(x=p95, line=dict(color=col, width=1.5, dash="dot"), row=1, col=1) fig.add_annotation( x=p95, y=yref, xref="x", yref="y domain", text=f"P95 ${p95:.2f}M", font=dict(size=9, color="white", family="monospace"), bgcolor=col, borderpad=3, bordercolor=col, showarrow=True, arrowhead=0, arrowwidth=1, arrowcolor=col, ax=30, ay=0 ) # ── Panel 2: box plots ── for name, arr in results.items(): col = mc_colors[name] fig.add_trace(go.Box( y=arr / 1e6, name=name.split(". ")[1], marker_color=col, boxmean=True, legendgroup=name, showlegend=False, hovertemplate="" + name + " Value: $%{y:.2f}M<extra></extra>" ), row=1, col=2) fig.update_layout( barmode="overlay", height=490, title=dict(text="Monte Carlo — 10,000 Simulations of Total Annual Exposure", font=dict(size=15)), template="plotly_white", font=dict(family="Segoe UI, Helvetica, Arial, sans-serif", size=12), legend=dict(orientation="h", yanchor="bottom", y=1.05, xanchor="center", x=0.31, font=dict(size=11)), hoverlabel=dict(bgcolor="white", font_size=11, font_family="monospace"), margin=dict(t=95, b=45) ) fig.update_xaxes(title_text="12-month total cost (USD millions)", row=1, col=1) fig.update_yaxes(title_text="Frequency", row=1, col=1) fig.update_yaxes(title_text="Cost (USD millions)", row=1, col=2) fig.show() ``` ## Interpretation The status-quo distribution carries both a high mean cost and a pronounced right tail driven primarily by the renewal-revenue layer — losing a single Tier-1 bank contract represents up to USD 900 k of ARR. Scenario C (Pod re-organisation, USD 25 k) produces a modest leftward shift with limited tail-risk reduction. Scenario B (+2 L2 engineers, USD 60 k) reduces the mean more meaningfully but leaves the tail largely intact. The **Comprehensive intervention (Scenario D, USD 110 k)** achieves the largest combined reduction in both expected cost and P95 tail exposure. The savings are dominated by renewal-revenue protection, not by SLA-penalty savings alone — confirming that the investment case must be argued on **tail-risk**, not expected value alone. # Analysis 3 — Advanced Forecasting ## Theory recap Holt's linear-trend exponential smoothing fits a level $\ell_t$ and a trend $b_t$ updated by smoothing parameters $\alpha$ and $\beta$. With 7 monthly observations (June–December 2025) Holt is the appropriate choice: SARIMA(p,d,q)(P,D,Q) typically requires 24 + monthly observations to fit a seasonal cycle reliably. We always benchmark against a naïve seasonal forecast. ## Business justification The forecast drives next-quarter L2 / L3 staffing and the on-call rota. The CFO needs both a point estimate and a 95 % interval so we plan against the realistic upper end of demand — particularly important for USL given the sharp decline from 712 cases in June 2025 to 208 in December 2025 and the uncertainty over whether that trend will continue or reverse in 2026. ## Code & output ```{python} #| label: forecast # Use only cases with parseable dates (from case reference pattern PREFIX/DD/MM/NNNN) m = (df.dropna(subset=["CREATED_DATE"]) .set_index("CREATED_DATE") .resample("MS").size() .rename("cases") .asfreq("MS", fill_value=0)) mod = Holt(m, initialization_method="estimated").fit(optimized=True) fc = mod.forecast(6).round() sd = (m - mod.fittedvalues).std() ci_low, ci_high = fc - 1.96*sd, fc + 1.96*sd obs_x = [str(t.date()) for t in m.index] fc_x = [str(t.date()) for t in fc.index] fig = go.Figure() # ── 95% confidence band ── fig.add_trace(go.Scatter( x=fc_x, y=ci_high.values.tolist(), mode="lines", line=dict(width=0), showlegend=False, hoverinfo="skip" )) fig.add_trace(go.Scatter( x=fc_x, y=ci_low.values.tolist(), mode="lines", line=dict(width=0), fill="tonexty", fillcolor="rgba(215,38,61,0.12)", name="95% Confidence Band", hoverinfo="skip" )) # ── Observed series — filled area + line + markers ── fig.add_trace(go.Scatter( x=obs_x, y=m.values.tolist(), mode="lines+markers+text", name="Observed (Jun–Dec 2025)", line=dict(color="#2E86AB", width=3), marker=dict(size=10, color="#2E86AB", line=dict(width=2, color="white")), text=[f"{v:,}" for v in m.values], textposition="top center", textfont=dict(size=10, color="#2E86AB"), fill="tozeroy", fillcolor="rgba(46,134,171,0.08)", hovertemplate="%{x} Cases: %{y:,}<extra>Observed</extra>" )) # ── Holt forecast line ── fig.add_trace(go.Scatter( x=fc_x, y=fc.values.tolist(), mode="lines+markers+text", name="Holt Forecast (6-month)", line=dict(color="#D7263D", width=3, dash="dash"), marker=dict(size=10, symbol="diamond", color="#D7263D", line=dict(width=2, color="white")), text=[f"{v:,.0f}" for v in fc.values], textposition="top center", textfont=dict(size=10, color="#D7263D"), hovertemplate="%{x} Forecast: %{y:,.0f} cases<extra>Holt</extra>" )) # ── Annotation for peak & trough ── peak_idx = int(np.argmax(m.values)) fig.add_annotation( x=obs_x[peak_idx], y=int(m.values[peak_idx]), text=f"▲ Peak: {int(m.values[peak_idx]):,}", showarrow=True, arrowhead=2, arrowcolor="#2E86AB", font=dict(size=11, color="#2E86AB", family="monospace"), ax=40, ay=-35 ) fig.update_layout( title=dict(text="USL ISURA — Monthly Case Volume & 6-Month Holt Forecast", font=dict(size=15)), xaxis=dict(title="Month", rangeslider=dict(visible=True, thickness=0.06), showspikes=True, spikemode="across", spikethickness=1, spikecolor="#888"), yaxis=dict(title="Cases per month", showspikes=True, spikethickness=1, spikecolor="#888"), hovermode="x unified", template="plotly_white", font=dict(family="Segoe UI, Helvetica, Arial, sans-serif", size=12), height=480, legend=dict(orientation="h", yanchor="bottom", y=1.04, xanchor="center", x=0.5, font=dict(size=11)), hoverlabel=dict(bgcolor="white", font_size=11, font_family="monospace"), margin=dict(t=85) ) fig.show() print("Observed monthly volume:") print(m.to_string()) print("\nHolt parameters:") print(f" alpha (level) = {mod.params['smoothing_level']:.3f}") print(f" beta (trend) = {mod.params['smoothing_trend']:.3f}") print(f" in-sample SSE = {mod.sse:.0f}") print("\nForecast:") print(pd.concat([fc.rename("forecast"), ci_low.rename("low95"), ci_high.rename("high95")], axis=1).round(0).to_string()) ``` ## Interpretation The date-parseable series (June–December 2025, n = 3,194 cases) shows a clear **downward trend**: volume fell from 712 cases in June to 208 in December — a 71 % reduction over seven months — with a minor uptick in November (387 cases) that may reflect a quarter-end batch-processing cycle. Holt captures this declining trajectory and projects further softening into mid-2026. **The 95 % forecast band is wide**, which is the correct signal given only seven training observations: the upper bound should drive L2 / L3 staffing decisions rather than the point forecast, retaining capacity to absorb any demand reversal. The November uptick warrants monitoring — if it recurs it would suggest nascent seasonality. With 24 + months of history we would upgrade to SARIMA(0,1,1)(0,1,1)[12] or to Prophet with explicit Nigerian banking holidays and a regressor for quarter-end trade-finance runs. # Analysis 4 — Customer / People Analytics (Cox PH) ## Theory recap Cox proportional-hazards models the *hazard* — instantaneous probability of an event at time $t$ given still-at-risk — as $h(t \mid x) = h_0(t) \exp(\beta_1 x_1 + \dots + \beta_k x_k)$. $\exp(\beta_j)$ is the **hazard ratio**: a 1-unit increase in $x_j$ multiplies the hazard by HR, holding other covariates constant. ## Business justification Treating "did the case breach SLA?" as a yes/no logistic problem throws away the *time* dimension. Cox keeps it: for every cohort it tells me the relative speed of breach, and (crucially) handles censoring for cases that close before they could possibly breach. ## Code & output ```{python} #| label: cox cox_df = df[df["RESOLUTION_TIME_HOURS"] > 0.001].copy() # avoid zero durations cox_X = pd.get_dummies( cox_df[["RESOLUTION_TIME_HOURS","BREACH","CASE_SEVERITY","PRODUCT_NAME","COMPANY_NAME"]], drop_first=True ).astype(float) cph = CoxPHFitter(penalizer=0.05).fit(cox_X, duration_col="RESOLUTION_TIME_HOURS", event_col="BREACH") print(f"n = {cox_X.shape[0]:,}, breach events = {int(cox_X['BREACH'].sum()):,}") print(f"Concordance index = {cph.concordance_index_:.3f}\n") cph.summary[["coef","exp(coef)","se(coef)","z","p"]].round(3) ``` ```{python} #| label: km #| fig-cap: "Kaplan-Meier — probability of NO SLA breach yet, by product" kmf = KaplanMeierFitter() fig = go.Figure() km_colors = {"KACHASI v2.x": "#2E86AB", "KACHASI v1.x": "#A23B72", "TENTACLES": "#F18F01", "DATASTORE": "#44BBA4"} # ── SLA threshold zones (shaded vertical bands behind curves) ── sla_bands = [ (0.1, 24, "CRITICAL ≤ 24h", "#FDECEC"), (24, 72, "HIGH ≤ 72h", "#FFF3E0"), (72, 120, "MEDIUM ≤ 120h", "#F0F4C3"), (120, 240, "LOW ≤ 240h", "#E8F5E9"), ] for x0, x1, label, bgcolor in sla_bands: fig.add_vrect( x0=x0, x1=x1, fillcolor=bgcolor, opacity=0.55, layer="below", line_width=0, ) fig.add_annotation( x=np.log10(np.sqrt(x0 * x1)) if x0 > 0 else np.log10(x1 / 2), y=1.02, yref="y domain", text=f"{label}", font=dict(size=8.5, color="#555"), showarrow=False, xref="x" ) # ── Survival curves — clean lines, no fill ── for prod in sorted(km_colors.keys()): msk = df["PRODUCT_NAME"] == prod if msk.sum() == 0: continue kmf.fit(df.loc[msk, "RESOLUTION_TIME_HOURS"], df.loc[msk, "BREACH"], label=prod) sf = kmf.survival_function_ t = sf.index.tolist() s = sf.iloc[:, 0].tolist() n = int(msk.sum()) col = km_colors[prod] # Step shape t_step, s_step = [], [] for i in range(len(t) - 1): t_step += [t[i], t[i+1]] s_step += [s[i], s[i]] t_step.append(t[-1]); s_step.append(s[-1]) fig.add_trace(go.Scatter( x=t_step, y=s_step, mode="lines", name=f"{prod} (n = {n:,})", line=dict(color=col, width=3), hovertemplate=( "" + prod + " " "Hours: %{x:,.1f} " "Survival: %{y:.1%}<extra></extra>" ) )) # ── 50% survival reference ── fig.add_hline(y=0.5, line=dict(color="#AAAAAA", width=1, dash="dash")) fig.add_annotation( x=1.0, y=0.50, xref="paper", text="50 % survival", font=dict(size=9, color="#999"), showarrow=False, xanchor="left", xshift=5 ) fig.update_xaxes( type="log", title_text="Hours since case opened (log scale)", showgrid=False, showspikes=True, spikemode="across", spikethickness=1, spikecolor="#bbb", spikedash="dot", range=[np.log10(0.5), np.log10(10000)] ) fig.update_yaxes( title_text="P (no SLA breach yet)", range=[-0.02, 1.08], tickformat=".0%", showgrid=True, gridwidth=0.5, gridcolor="rgba(0,0,0,0.06)", zeroline=False ) fig.update_layout( title=dict( text="Time-to-SLA-Breach by Product — Kaplan-Meier Survival Curves", font=dict(size=15)), template="plotly_white", font=dict(family="Segoe UI, Helvetica, Arial, sans-serif", size=12), height=500, hovermode="closest", legend=dict( orientation="h", yanchor="bottom", y=-0.18, xanchor="center", x=0.5, font=dict(size=11), bgcolor="rgba(255,255,255,0.85)", bordercolor="#ddd", borderwidth=1 ), hoverlabel=dict(bgcolor="white", font_size=11, font_family="monospace"), margin=dict(t=80, b=80) ) fig.show() ``` ## Interpretation The Cox proportional-hazards model on all 5,035 cases produces stable hazard ratios (concordance index reported above). The dominant protective covariate is `CASE_SEVERITY = LOW`: its generous SLA window makes breach structurally unlikely, yielding a strongly sub-unity hazard ratio. Conversely, CRITICAL and HIGH severity cases accelerate the hazard substantially — consistent with their tighter SLA windows and the observed overall breach rate. At the product level, **DATASTORE** carries the highest breach hazard after controlling for severity, reflecting its long-running batch reconciliation workloads; KACHASI v1.x sits closest to the baseline. Bank-level effects are attenuated once severity and product are held constant, but **Coronation Merchant Bank** shows an elevated residual hazard — a priority target for the dedicated retention pod proposed in Scenario D. The Kaplan-Meier curves corroborate these findings: all product survival functions drop steeply in the first 72 hours, confirming that most breaches occur early in a case's lifecycle and that fast initial triage is the highest-leverage intervention point. # Analysis 5 — Optimisation (Linear Programming) ## Theory recap Linear programming maximises $c^\top x$ subject to $A x \le b$, $x \ge 0$. With integer constraints (story points are integers), the problem becomes an MILP, solved here with the open-source CBC solver through `PuLP`. ## Business justification The fortnightly sprint allocation is a constrained decision: 240 story-points across five tracks (Bugs, Change Requests, Compliance, Platform, Performance) under regulator floors and capacity caps. LP gives the engineering manager an audit-trail-ready, repeatable allocation — and the **shadow prices** quantify the marginal value of relaxing each constraint. ## Code & output ```{python} #| label: lp items = pd.DataFrame({ "Track": ["Bugs","ChangeRequests","Compliance","Platform","Performance"], "ValuePerPoint": [3.5, 5.5, 4.2, 1.6, 3.0], "Min": [60, 0, 40, 0, 20], "Max": [120, 110, 80, 60, 60], }) prob = pulp.LpProblem("usl_capacity", pulp.LpMaximize) x = {t: pulp.LpVariable(f"x_{t}", lowBound=int(items.loc[items.Track==t,"Min"].iloc[0]), upBound=int(items.loc[items.Track==t,"Max"].iloc[0]), cat=pulp.LpInteger) for t in items["Track"]} prob += pulp.lpSum([items.loc[items.Track==t,"ValuePerPoint"].iloc[0] * x[t] for t in items["Track"]]) prob += pulp.lpSum(list(x.values())) <= 240, "TotalPoints" prob.solve(pulp.PULP_CBC_CMD(msg=False)) lp_out = pd.DataFrame({ "Track": items["Track"], "ValuePerPoint": items["ValuePerPoint"], "Optimal_pts": [int(x[t].value()) for t in items["Track"]], }) lp_out["Value"] = lp_out["ValuePerPoint"] * lp_out["Optimal_pts"] print("Status:", pulp.LpStatus[prob.status]) print(f"Objective = {pulp.value(prob.objective):.1f}") print(f"Total points used = {lp_out['Optimal_pts'].sum()} of 240") # Build merged-header display table lp_display = items.copy().merge( lp_out[["Track", "Optimal_pts", "Value"]], on="Track" ) lp_display.columns = pd.MultiIndex.from_tuples([ ("Input Parameters", "Track"), ("Input Parameters", "Value / Point ($)"), ("Input Parameters", "Min (pts)"), ("Input Parameters", "Max (pts)"), ("LP Solution", "Optimal (pts)"), ("LP Solution", "Total Value ($)"), ]) lp_display.style.format({ ("Input Parameters", "Value / Point ($)"): "${:.1f}", ("LP Solution", "Total Value ($)"): "${:,.0f}", }).hide(axis="index") ``` ```{python} #| label: lp-plot #| fig-cap: "Optimal sprint capacity allocation" #| output: true # Colour-code bars by value-per-point intensity vpp = lp_out["ValuePerPoint"].tolist() vpp_norm = [(v - min(vpp)) / (max(vpp) - min(vpp) + 1e-9) for v in vpp] bar_cols = [f"rgba({int(215*n + 46*(1-n))},{int(38*n + 134*(1-n))},{int(61*n + 171*(1-n))},0.85)" for n in vpp_norm] # gradient from cool blue → hot red fig = ps.make_subplots( rows=1, cols=2, column_widths=[0.62, 0.38], specs=[[{"type": "xy"}, {"type": "pie"}]], subplot_titles=["Points Allocated per Track", "Share of Sprint Capacity"], horizontal_spacing=0.08 ) # ── Bar chart with min/max constraint markers ── tracks = lp_out["Track"].tolist() opt_pts = lp_out["Optimal_pts"].tolist() min_pts = items["Min"].tolist() max_pts = items["Max"].tolist() fig.add_trace(go.Bar( x=opt_pts, y=tracks, orientation="h", marker=dict(color=bar_cols, line=dict(width=1, color="#333")), text=[f"{v} pts (${val:.0f} value)" for v, val in zip(opt_pts, lp_out["Value"])], textposition="outside", textfont=dict(size=11), hovertemplate=( "%{y} " "Allocated: %{x} pts " "Value/pt: $%{customdata[0]:.1f} " "Min: %{customdata[1]} | Max: %{customdata[2]} " "Total value: $%{customdata[3]:.0f}<extra></extra>" ), customdata=list(zip(vpp, min_pts, max_pts, lp_out["Value"].tolist())), showlegend=False ), row=1, col=1) # Min constraint diamonds fig.add_trace(go.Scatter( x=min_pts, y=tracks, mode="markers", name="Min constraint", marker=dict(symbol="diamond", size=10, color="#F18F01", line=dict(width=1.5, color="#333")), hovertemplate="%{y} — Min floor: %{x} pts<extra></extra>" ), row=1, col=1) # Max constraint diamonds fig.add_trace(go.Scatter( x=max_pts, y=tracks, mode="markers", name="Max cap", marker=dict(symbol="diamond", size=10, color="#D7263D", line=dict(width=1.5, color="#333")), hovertemplate="%{y} — Max cap: %{x} pts<extra></extra>" ), row=1, col=1) # ── Donut chart for share breakdown ── fig.add_trace(go.Pie( labels=tracks, values=opt_pts, hole=0.45, marker=dict(colors=bar_cols, line=dict(width=2, color="white")), textinfo="label+percent", textfont=dict(size=11), hovertemplate="%{label} %{value} pts (%{percent})<extra></extra>", showlegend=False ), row=1, col=2) # Centre annotation for donut fig.add_annotation( text=f"240 total pts", x=0.82, y=0.5, xref="paper", yref="paper", font=dict(size=14, color="#333"), showarrow=False ) fig.update_layout( title=dict(text="Optimal Sprint Capacity Allocation (240 SP)", font=dict(size=15)), template="plotly_white", font=dict(family="Segoe UI, Helvetica, Arial, sans-serif", size=12), height=420, legend=dict(orientation="h", yanchor="bottom", y=-0.15, xanchor="center", x=0.31, font=dict(size=11)), hoverlabel=dict(bgcolor="white", font_size=11, font_family="monospace"), margin=dict(t=80, b=30) ) fig.update_xaxes( title_text="Story points", range=[0, max(max_pts) * 1.65], automargin=True, row=1, col=1 ) fig.update_yaxes(automargin=True, row=1, col=1) fig.update_layout(margin=dict(t=80, b=30, r=40)) fig.show() ``` ## Interpretation {style="margin-top: -1.5rem;"} The LP solver returns **Change Requests 110 pts (at cap), Bugs 60 pts (at floor), Compliance 50 pts, Performance 20 pts (at floor), Platform 0 pts** — consuming all 240 sprint points and achieving an objective of 1,085 value-units. Three outcomes are worth highlighting. First, Change Requests are allocated their full ceiling: at USD 5.5 value per point they are the highest-returning track and the model exploits that to the limit. Second, Platform capacity is driven to zero — at 1.6 value per point it is the marginal track, so tech-debt investment is **explicitly deferred**, not forgotten; the shadow price on the total-points constraint (≈ 5.5 value-units / SP) quantifies exactly what USL forgoes per point by not hiring. Third, Compliance holds at 50 points — above its 40-point regulatory floor — ensuring the CBN minimum is met while leaving headroom for the Change Request priority. This allocation should be reviewed each sprint as the Text Analytics classifier updates the theme-to-severity mapping. # Integrated Findings | Step | Cadence | Technique | What it produced for USL | |-----:|:-----------|:---------------------------|:--------------------------| | 1 | Weekly | Text analytics | Themed roadmap input + auto-triage baseline on real titles | | 2 | Sprint (2-wk) | LP optimisation | 240 SP split: CR 110, Bugs 60, Comp 50, Perf 20, Plat 0 | | 3 | Monthly | Holt forecast | Forward case-volume + 95 % bands → L2 / L3 staffing | | 4 | Quarterly | Cox PH | DATASTORE most-at-risk product; LOW-severity protective; per-bank cohorts surfaced | | 5 | Quarterly | Monte Carlo | Comprehensive scenario removes the largest slice of P95 tail-risk | The five techniques chain into a single recommendation: **adopt Scenario D (Comprehensive — new pod + automation playbooks) at the next board meeting**. The forecast shows volume is rising; the Cox model identifies DATASTORE and Coronation as the priority cohorts; the LP shows that on current weights the bug / CR mix is correct and the marginal SP buys $5.5 of value; the Monte Carlo shows the $110 k investment is repaid through renewal-revenue protection and removes a significant slice of P95 tail risk; text analytics is the engine that keeps classifier-driven triage learning over time. # Limitations & Further Work - **Resolution-time tail.** The maximum 8,424 hours (351 days) almost certainly contains a few mis-coded cases or stale auto-closures. Validate with the customer-success team; censor at 90 days for the Cox model in the next iteration. - **ARR figures are illustrative.** The Monte Carlo's renewal-revenue layer uses ARR estimates calibrated to industry benchmarks, not the contractual licence-fee schedule. Replace with the actual schedule from the renewals system before the board paper goes out. - **Renewal model.** The $P(\text{churn}) = 0.02 + 1.5 \cdot (\text{breach rate} - 0.10)$ curve is a parametric assumption. Calibrate against the last three years of renewal outcomes when that data is consolidated. - **Causality.** Every coefficient in this paper is observational. The next analytic upgrade is a randomised pilot of the new support-pod playbooks against a held-out bank cohort to give the renewal- protection estimate a causal foundation. - **Computing power / scale.** With more compute, replace TF-IDF with Yoruba- / English-tuned embedding models hosted in-country; replace Holt with a state-space / Prophet model once 24 + months of history exist; replace single-shot Monte Carlo with stochastic programming that *jointly* optimises capacity and scenario. - **Single severity scheme.** SLA targets here use a four-tier CRITICAL / HIGH / MEDIUM / LOW mapping. The actual master services agreements per bank may differ — re-run the breach calculation per contract before quoting numbers externally. # References {.unnumbered} ::: {#refs} - Box, G. E. P., Jenkins, G. M., Reinsel, G. C., & Ljung, G. M. (2015). *Time series analysis: forecasting and control* (5th ed.). Wiley. - Davidson-Pilon, C. (2019). lifelines: survival analysis in Python. *Journal of Open Source Software, 4*(40), 1317. https://doi.org/10.21105/joss.01317 - Hyndman, R. J., & Athanasopoulos, G. (2021). *Forecasting: principles and practice* (3rd ed.). OTexts. https://otexts.com/fpp3/ - McKinney, W. (2010). Data structures for statistical computing in Python. *Proceedings of the 9th Python in Science Conference*, 56–61. - Mitchell, S., O'Sullivan, M., & Dunning, I. (2011). PuLP: a linear programming toolkit for Python. https://github.com/coin-or/pulp - Pedregosa, F. et al. (2011). Scikit-learn: machine learning in Python. *Journal of Machine Learning Research, 12*, 2825–2830. - Seabold, S., & Perktold, J. (2010). statsmodels: econometric and statistical modeling with Python. *Proceedings of the 9th Python in Science Conference*, 92–96. - Central Bank of Nigeria. (2024). *Risk-based cybersecurity framework and guidelines for deposit money banks and payment service providers (revised)*. CBN Banking Supervision Department. - Adi, B. (2026). *AI-powered business analytics: a practical textbook for data-driven decision making*. Mark Analytics. https://markanalytics.online/ai-powered-data-analytics/ ::: # Appendix — AI Usage Statement {.unnumbered} I used **Claude (Anthropic)** for two specific tasks: (1) drafting the boilerplate scaffold for the Monte Carlo simulation function and the Quarto YAML / section structure, and (2) double-checking statsmodels and lifelines syntax. All scenario design (intervention costs, breach- reduction percentages, renewal-curve shape), all interpretation of hazard ratios, the analytical question, the choice of Holt over SARIMA given the 12-observation window, the LP value-weights, and the recommendation to the board are my independent professional judgement as CTO of USL. Every numerical result is computed live in this document on the **5,035-row real ISURA dataset** and cross-checked against my own knowledge of USL's historical SLA performance before inclusion.