Appiffy/bank-deployment-blind-spot-eval

Bank Deployment Blind Spot Evaluation

A matched-pair evaluation of Qwen2.5-3B-Instruct on 80 practitioner-written questions about software deployment, split 40/40 between a bank setting and a startup setting. Submitted for the Fatima Institute technical challenge Blind Spots of Frontier Models.

---

TL;DR

The hypothesis was that a small open-weight model would answer every deployment question with a startup-shaped recipe and under-score on the bank side. The data says the opposite. The model is enterprise-shaped: it reaches for a cautious, bullet-pointed, process-aware answer no matter who is asking. The blind spot is a one-directional failure to downshift caution when the setting is a small startup where lightweight answers are correct.

Metric	Bank	Startup
Mean rubric score (0–1)	0.49 ± 0.29	0.39 ± 0.26
Skip-question verdict accuracy	0.50 (4/8)	0.00 (0/8)

Paired t = 2.20, p = 0.034, Cohen's d = +0.35 (bank side scores significantly higher). On all eight startup "can I skip this" questions the model refused to permit the skip — zero correct verdicts.

---

1. The blind spot (my motivation)

so here is my motivation I began this project by trying to think of questions that would expose a gap in an AI model. My mind stayed empty. Then I realised that the best material is the world I already know. After working in a bank I have seen how slow and layered deployment can be. A new solution does not go live simply because the team built it. It moves from one approval to the next: design review, security testing requests to open network ports, a change board, business sign-off and a go/no-go decision. Every step exists for a reason. Every bank does it a little differently.

Now imagine I ask an AI model "I have built an app. How do I deploy it?" The AI model will probably give me a list of steps. The AI model will not ask whether I am deploying inside a bank whether the app sits on the bank’s network or who has to approve the firewall request. The AI model answers as if I were a startup that can ship on a Friday afternoon. The advice sounds confident and sensible. For my situation it is incomplete and it could be wrong.

I think this matters because the people most likely to trust that advice are the people unable to spot what is missing: new engineers, junior project staff and teams under deadline pressure. If they follow a startup-style answer they could skip an approval open a port they should not open or promise a date that cannot happen. The customers behind the system are affected last. They are the reason those controls exist.

Instead of guessing I built my own test. I wrote forty matched pairs of questions one set for a bank and one, for a startup covering networks, security, approvals, disaster recovery, data migration, training and go-live day. Then I will measure whether a small open AI model changes its answers to fit the setting or gives the easy answer to both. This is a gap that standard benchmarks rarely look at. I know it from experience not from a textbook.

---

2. How I evaluated the gap

Dataset

80 questions in eval_questions.csv:

• 40 matched pairs. Each bank question has a startup counterpart with the same topic and the same question style.
• 8 topics. Network and ports · Development · Security · Approvals · Disaster recovery · Data migration · Training and branch readiness · Go-live day.
• 5 question styles per topic. what_is_needed · which_first · can_we_skip · why_delayed · who_approves.
• 4 rubric points per row. Pipe-separated in the must_mention column.
• Expected verdict on the 16 can_we_skip rows: no for every bank question, usually yes for every startup question.

Model

Field	Value
Name	Qwen/Qwen2.5-3B-Instruct
Parameters	3.09 B
Licence	Qwen research licence (open weight, non-gated)
Why chosen	Sits inside the 0.6–6B window set by the brief; strong instruction tuning for its weight class; non-gated so the whole evaluation reproduces on a free Colab T4

Procedure

1. Run the model on all 80 questions with greedy decoding (do_sample=False, max_new_tokens=320). The system prompt is neutral and never names the setting — the setting is only ever present in the words of the user question, mirroring how a non-expert user would ask.
2. Save raw answers to eval_results_raw.csv.
3. Score each row programmatically. Embed the four rubric points with sentence-transformers/all-MiniLM-L6-v2, embed each sentence of the model answer, count a point as hit when cosine similarity ≥ 0.45.
4. Verdict classification on the 16 can_we_skip rows: a rule-based classifier reads the opening of the answer and resolves it to yes, no or unclear; this is compared against the expected verdict.
5. Save the scored table as eval_results_scored.csv, the dashboard as chart.png, and curated failures as failure_examples.md.

The full pipeline lives in notebook.ipynb and runs end to end on a free Colab T4 in roughly twenty minutes.

---

3. Results

Headline numbers

	Bank	Startup	Difference
Overall mean rubric score	0.494 ± 0.286	0.394 ± 0.259	+0.100 (bank higher)
Paired t-test across 40 pairs	—	—	t = 2.20, p = 0.034
Cohen's d (paired)	—	—	+0.35
Skip-question verdict accuracy	0.50 (4/8)	0.00 (0/8)	—

What the study found — and what it expected

Going in, I expected the opposite result. The hypothesis was that the model would answer both contexts with a startup-shaped recipe and under-score on bank items. The data says something more interesting: the model is enterprise-shaped, not startup-shaped.

Bank items score higher than startup items on every topic in the breakdown — Disaster recovery (0.65 vs 0.40), Security (0.75 vs 0.60), Approvals (0.50 vs 0.35), and so on — and the overall difference is statistically significant in favour of the bank side. The model reaches for a cautious, process-aware, bullet-pointed answer regardless of who is asking. That style happens to match the bank rubric reasonably well, and happens to miss the startup rubric, which rewards short, lightweight, "yes just do it with a note" answers.

The skip-question verdict accuracy makes this concrete. On the eight bank skip questions the expected answer is no and the model gets half of them right. On the eight startup skip questions the expected answer is usually yes and the model gets none of them right. It never once told a startup it could skip a step — not for a port request, not for a small production fix, not for a pre-release team check, not for a backup-restore test, not for a go/no-go meeting. Every startup skip question is answered with the same hedged "this can be risky, here is a structured approach" preamble a bank answer would get.

So the blind spot visible in this probe is the inverse of my prior. A small open-weight model trained on broad instruction data appears to default to a single caution posture and does not downshift it when the setting makes caution excessive. On the bank side, this is mostly fine. On the startup side it produces advice that is confidently wrong — not in content, but in weight.

Where the gap concentrates

By topic. Bank wins or ties on all eight topics; startup never wins any. The widest bank-side gaps are on Disaster recovery (+0.25), Security (+0.15) and Approvals (+0.15) — the topics where enterprise ceremony is most rewarded by the rubric.

By question style.

Style	Bank	Startup	Gap (bank − startup)
can_we_skip	0.56	0.28	+0.28
what_is_needed	0.63	0.47	+0.16
who_approves	0.44	0.31	+0.13
which_first	0.63	0.59	+0.03
why_delayed	0.22	0.31	−0.09

can_we_skip and what_is_needed are precisely the styles where a bank answer wants process language and a startup answer wants permission to be casual — and this is where the enterprise bias bites hardest. The one style where startup edges ahead is why_delayed: here the bank rubric expects bank-specific reasons (change board not meeting, port request waiting for approval) and the model instead falls back to a generic technical troubleshooting list. That failure mode is visible in failure_examples.md under bank-casual answers.

Failure families in failure_examples.md

• Bank-casual. Bank questions where the model reaches for generic technical reasons rather than naming the specific bank controls the rubric expects.
• Startup-paranoid. Startup questions buried in enterprise ceremony.
• Verdict flips. The 16 can_we_skip rows where the model's opening polarity disagrees with the expected verdict — dominated by the eight startup items where the model refused to permit a skip.

---

4. Path forward (speculative)

The results reframe the problem. The question is no longer "how do we teach this model what a bank is" — the model already answers bank questions reasonably well. The question is "how do we teach the model to downshift its caution when the setting invites a lightweight answer." The gap is one-directional and it lives on the startup side.

My hunch is that this bias is picked up during instruction tuning and safety fine-tuning. The reward model has learned that hedged, structured, risk-flagging answers are generally preferred, and that preference does not condition on the user's organisational scale. If that is right, three directions are worth trying — now ordered by the cost of the fix, cheapest first.

1. A context-adaptive system prompt. Before touching weights, test whether an opening instruction like "If the user's setting is a small team or startup where speed matters more than formal controls, keep answers short and permit skipping process steps that are not legally required" flips the startup skip accuracy from 0.00 to something non-zero. If it does, the capability is already in the model and the production fix is a prompt layer that infers the setting from the message. If it does not, the model genuinely cannot downshift and the problem is in the weights.

2. Preference data that includes "permit the skip" trajectories. Public post-mortems, hacker-news-style war stories, and small-team engineering blogs are full of examples where the right move was to ship, patch, or skip a formality — and where ceremony would have been wrong. A compact preference dataset built from this material, where the preferred response for a startup-flagged prompt is the shorter and more permissive one, directly targets the asymmetry this study found.

3. A caution-shift LoRA adapter. With the preference data from (2), a small adapter can be trained with the objective of lowering refusal and lengthening permissiveness specifically when a startup, small-team, or hobby-project framing is detected. The adapter stays tiny; the base model is unchanged for every other use.

Direction 1 is the one I would try first. If a prompt alone cannot move a 0.00 verdict accuracy, the deeper fixes are worth the trouble. If it can, the right production answer is probably a context layer, not a new model.

---

5. Limits

• 80 questions, one model, one author. The dataset is a small probe, not a benchmark.
• Scoring is automated via sentence-embedding similarity against a four-point rubric, with a cosine threshold of 0.45. An answer that covers a rubric point in very different wording can be marked as missing it, and vice versa. A hand-review pass on eval_results_scored.csv is the natural next step.
• The verdict classifier on the 16 can_we_skip rows is a simple rule over the opening of the answer. It can misread a hedged answer that technically contains both a negation and an affirmation.
• Describes a gap on this probe, with this model, under this scoring procedure. Does not prove a general law about frontier models.

---

Reproducing the evaluation

1. Open Google Colab, create a new notebook, then Runtime > Change runtime type > T4 GPU.
2. Upload notebook.ipynb and eval_questions.csv to the Colab working directory.
3. Runtime > Run all. End-to-end runtime is ~20 minutes on a T4.
4. The notebook writes eval_results_raw.csv, eval_results_scored.csv, chart.png, and failure_examples.md into the working directory.

---

Files in this repository

File	Purpose
README.md	This file (the dataset card).
eval_questions.csv	The 80 questions with rubric points and expected verdicts.
eval_results_raw.csv	Questions plus raw model answers (checkpoint).
eval_results_scored.csv	Full scored table — the primary artifact.
chart.png	Four-panel dashboard figure (headline figure).
failure_examples.md	Curated failure examples by failure family.
notebook.ipynb	End-to-end Colab notebook that produced every artifact.

---

Citation

If this evaluation is useful to you, please cite it as:

Ogboi, F. (2026). Bank Deployment Blind Spot Evaluation of Qwen2.5-3B-Instruct.
Submitted for the Fatima Institute Technical Challenge: Blind Spots of
Frontier Models.