How a Commercial Banking Unit Linked Training to Cycle Time and Exception Rates with Auto-Generated Quizzes and Exams

Commercial Banking Units Face High Stakes in Fast Changing Markets

Commercial Banking Units sit at the center of complex, high‑value work. Teams help businesses secure credit, set up treasury services, and move money safely. Every deal involves many steps, many systems, and many people. The stakes are high because clients expect speed and accuracy, and regulators expect proof that every rule is followed.

Here is the day‑to‑day snapshot. Relationship managers gather client needs. Credit analysts assess risk and structure terms. Operations specialists collect documents, verify identities, book loans, and activate services. Each step must follow current policy. Products change, forms change, and platforms update often. Demand also swings with the market. That mix makes it hard for staff to stay current and work in sync.

Leaders watch two numbers closely. Cycle time shows how long it takes to move from application to booking. Exception rates show the share of files that need rework because of missing data, wrong forms, or policy missteps. Slow cycles strain client trust and revenue. High exceptions increase cost and risk.

The learning challenge is clear. Policies shift many times a year. A slide deck or a once‑a‑year course cannot keep pace. New hires and veterans pick up tips in different ways, so results vary by team and by location. Managers often cannot see who knows what, or how training connects to the metrics that matter.

This creates an opening. If you treat learning as a source of real data, you can link what people know to how they perform. You can spot gaps early, target coaching, and standardize the steps that reduce errors and speed decisions. This case study shows how one unit took that path with auto‑generated assessments and a data backbone to track impact.

Complex Policies and Process Variability Challenge Consistent Performance

Commercial banking work sits on a moving target. Policies change. Products evolve. Risk appetite shifts with the market. Teams must apply the right rule to the right client at the right moment. One missed step can slow a deal or trigger a costly rework.

Consider a typical loan package. A client adds a new entity at the last minute. The credit memo needs an update. KYC rules require extra documents. Treasury onboarding uses a new form that looks like the old one. Each change seems small, but small gaps stack up across handoffs and systems.

• Frequent policy updates leave staff unsure which version to follow
• Many product variations create edge cases that are easy to miss
• Multiple systems and forms increase the chance of mismatched data
• Local workarounds drift from standard process over time
• Onboarding varies by team, so new hires ramp at different speeds
• Coaching happens late, often after a file fails quality checks
• Training data is thin, showing course completion but not true mastery

The result is uneven performance. Some deals sail through. Others bounce back for fixes. Cycle time stretches. Exception rates rise. Clients feel the delay, and auditors see the noise. Leaders know the pressure is real, yet they lack clear signals about where skills break down.

To turn the tide, teams need a simple way to check knowledge in the flow of work, spot gaps by product and process step, and respond before errors appear in live files. They also need proof that learning links to faster cycles and fewer exceptions. That is the gap this case study set out to close.

The Team Adopts a Data Driven Learning Strategy for Measurable Impact

The team set a simple goal. Make learning show up in the numbers that leaders watch, with faster cycle time and fewer exceptions. To get there, they treated assessments like sensors placed along the process. Short checks would confirm that people understood the latest policy before a task moved forward.

They chose auto‑generated quizzes to keep pace with change. Policies and workflows fed a living bank of questions and scenarios. Learners saw quick checks during onboarding, when a product update went live, and before high‑risk steps such as KYC, collateral, or booking.

• Align goals to business outcomes: tie learning targets to cycle time and exception rates
• Map knowledge to the work: tag every item by product line, process step, and policy version
• Capture data in one place: send xAPI statements to the Cluelabs xAPI Learning Record Store for real‑time views
• Connect learning to operations: export LRS data nightly and join it with BI reports on throughput and quality
• Act on signals fast: trigger refreshers and manager coaching when a cohort misses a key item
• Embed checks in the flow: place micro‑assessments in onboarding, release readiness, and pre‑submission checklists
• Protect trust and compliance: use clear roles, access controls, and an audit trail for reviews
• Pilot, learn, and scale: start small with one product, refine the items, then roll out across teams

Roles were clear. Subject matter experts reviewed questions for accuracy. L&D built prompts for the auto‑generated items and set mastery thresholds. Operations leaders chose where to place the checks. Data and analytics teams managed the LRS feed and the BI join.

Success meant more than course completions. The team tracked baseline and target cycle time, exception rates, time to proficiency for new hires, and adoption of the checks. They also watched item‑level trends to retire weak questions and add new ones when policies changed. This strategy made learning measurable and set up the solution described next.

Auto-Generated Quizzes and Exams Translate Policies into Practice

The team turned dense policies into short, practical checks that fit the workday. Auto‑generated quizzes and exams pulled from the latest policy notes, forms, and job aids to create fresh questions and mini cases. Subject matter experts reviewed the drafts for accuracy. Each check took only a few minutes and appeared at the moments when staff needed it most, such as after a new product release or right before a high‑risk step like Know Your Customer review or loan booking.

The questions looked like the job. Learners reviewed a document and spotted an error, chose the right form for a scenario, confirmed collateral steps, or calculated a coverage ratio. Exams combined several mini cases so people had to apply the rule, not just recall it. Feedback was clear and linked to the exact policy page or checklist so staff could fix a gap on the spot.

• Tag every item by product line, process step, and policy version to anchor learning to the workflow
• Use question blueprints to cover the most critical tasks and weight high‑risk items more heavily
• Place checks in the flow during onboarding, release readiness, and pre‑submission reviews
• Refresh knowledge over time with spaced follow‑ups and new variants that prevent answer memorizing
• Give targeted feedback with links to policy pages and job aids so learners can act right away
• Keep it accessible with short, mobile‑friendly sessions that fit between client tasks

When a policy changed, the bank updated the source text once and generated new items within the same day. Old questions were retired, and the exam blueprints pulled in the updated versions automatically. Different roles saw the checks that mattered to their tasks, so time spent on learning stayed focused.

Each attempt sent an xAPI record to the Cluelabs xAPI Learning Record Store, including the item ID and tags. This created a clean stream of data for coaching and for improving the item bank. If many learners missed the same step, the team tightened the wording, added an example, or built a quick micro‑lesson.

The result was a simple learner experience. Short checks showed up at the right time, gave clear feedback, and pointed to the exact rule to follow. Policies stopped feeling like dense documents and started to feel like everyday decisions people could make with confidence.

Cluelabs xAPI Learning Record Store Connects Assessments to Operations

The team used the Cluelabs xAPI Learning Record Store as the hub that tied learning to daily work. Every quiz and exam attempt sent an xAPI record to the LRS. Each record carried the item ID, the result, time on task, and tags for product line, process step, and policy version. This created a clean, time‑stamped trail of who knew what, when they learned it, and where gaps showed up.

Managers and subject matter experts could see simple, real‑time views. They filtered by role, team, branch, or product and spotted patterns fast. If a new KYC rule tripped up a cohort, the view made it obvious. If a policy changed, they could check which people had seen and passed the new items and which had not.

• Live dashboards show mastery by product, step, and policy version
• Cohort views highlight teams or roles that need help right now
• Item analysis flags confusing questions so authors can fix or replace them
• Targeted nudges trigger refreshers for people who miss a high‑risk step
• Readiness checks confirm that staff pass key items before a new release or task
• Role‑based access keeps data secure and gives each group the view they need
• Audit trail preserves evidence for compliance reviews, with dates and versions

Operations leaders used these signals in daily huddles. They picked one high‑impact step, reviewed the top missed item, and shared the correct move with a short demo or job aid. Team leads coached individuals who needed extra practice. New hires got a clear path to proficiency, not just a list of courses to click through.

The LRS also supported change at speed. When a policy update went live, the question bank refreshed, and the LRS tracked completions against the new version tag. People who had not yet met the bar received an automatic micro‑check and a link to the exact policy page. No guesswork. No mass emails.

For leadership, the LRS turned learning into numbers they could trust. It captured mastery, recency, and trends over time. It also made it easy to export data on a schedule and feed existing reports. That set the stage for linking learning to cycle time and exceptions, which the next section covers in detail.

Data Integration Links the LRS to BI and Operational Metrics

To link learning with real results, the team pulled quiz and exam data from the Cluelabs xAPI Learning Record Store into the business intelligence platform each night. They lined up those records with daily operations data on cycle time and exception rates. This let everyone see how mastery and recency of learning showed up in the work.

The match used simple keys. The same tags used in the quizzes — product line, process step, and policy version — plus team, role, and date were enough to join the data. With those anchors, leaders could check whether someone had passed the latest KYC step and then see how their next files moved through the pipeline.

• What they measured: mastery rate by product and step, days since last pass, readiness on new policy versions, and volume worked
• What they joined to: cycle time by stage, exception rates, rework counts, and simple deal traits such as product type and size
• How they kept it fair: compare like with like, focus on the current policy version, and filter out items that did not apply to a given role

The BI views were clear and practical. A heat map showed where low mastery sat next to high exceptions. Trend lines showed what happened before and after a policy release. Cohort views compared branches or roles, so managers could spot outliers and share what worked.

• Daily coaching cues: pick the top missed item in a step that also shows delays, then run a five minute refresher
• Release readiness: require a pass on the new version before staff touch live files, with the LRS tracking who cleared the bar
• Early warnings: trigger a micro‑check when days since last pass cross a set threshold
• Quality focus: target the one step that drives most rework for a product and watch exceptions drop

Patterns became easy to see. Teams that passed the new onboarding items within 30 days moved files faster and saw fewer quality flags. When mastery dipped, cycle time crept up in the next week. These findings helped leaders place training where it mattered most and retire activities that did not move the needle.

Data care mattered too. Access was role based. Personal views showed an individual only their own results, while managers saw rollups. The LRS export kept a full trail with dates and policy versions, which supported audits and reviews. With this link in place, learning stopped living in a separate system and started to shape operations in real time.

Training Mastery Correlates with Faster Cycle Time and Lower Exception Rates

The joined data told a clear story. When people passed the latest quizzes and exams, their next files moved faster and came back with fewer fixes. This held true across products and roles. Leaders could finally point to training mastery and see it show up in cycle time and exception rates.

Three patterns stood out again and again:

• Recency matters. Teams that passed key items in the last few weeks moved work through stages faster, especially in KYC and loan booking
• Mastery beats guesswork. Groups with higher pass rates on high risk steps had fewer rework tickets and fewer quality flags
• Release readiness pays off. Branches that cleared the new policy version before go live had smoother launches with fewer surprises

The team checked the findings in simple, fair ways so they could trust the signal:

• Like for like. Compare the same product, size, and stage across similar roles and time periods
• Current rules only. Focus on the latest policy version to avoid mixing old and new steps
• Right work, right people. Filter out items that do not apply to a role so the view reflects real tasks

Managers used these insights right away:

• Daily coaching. Pick the top missed item for a step that shows delays, run a five minute refresher, then send a quick recheck
• Pre work checks. Require a pass on critical items before a file moves to booking to prevent last minute rework
• Targeted nudges. When days since last pass crossed a set threshold, send a micro check linked to the exact policy page
• Smarter onboarding. New hires focused on the items that drive most errors, which cut time to confidence on live work

This is correlation, not lab proof of cause. Still, the timing made a practical case. When mastery rose, cycle time improved in the next few days and exception rates eased. When mastery dipped, the opposite followed. The pattern gave leaders a fast way to steer training toward the steps that move the business, and it gave L&D a shared language to discuss impact without guesswork.

Governance and Audit Trails Strengthen Banking Compliance and Trust

In banking, trust depends on proof. Leaders must show that people follow the latest rules, not just that they took a course months ago. The team built that proof into daily work. The Cluelabs xAPI Learning Record Store kept a time‑stamped record of each quiz and exam, who took it, what version of the policy it covered, and the result. That gave compliance teams a clear trail that matched learning to the exact rule in force at that moment.

Governance made the system reliable. Subject matter experts drafted and edited the items. L&D managed blueprints and publishing. Risk and Compliance reviewed high‑risk items before they went live. A simple change log showed what changed, why, and who approved it. Two people always reviewed critical steps like KYC, collateral, and loan booking.

• Role‑based access limited who could view or edit questions, results, and reports
• Version tags tied every item to a policy and date so teams trained on the right rule
• Readiness gates required a pass before staff touched files that used a new rule
• Recertification triggered short refreshers on a schedule or after missed items
• Data retention followed bank policy, with secure storage and easy exports for audits
• Exception handling sent a micro‑lesson and a recheck after repeated misses
• Item quality checks flagged confusing questions for rewrite or removal

Audits became faster and clearer. Reviewers could pull a sample of recent loans and match each file to the learner’s pass on the exact policy version used. The LRS export showed dates, item IDs, results, and links back to the policy page. This reduced back‑and‑forth and cut the time spent gathering evidence.

Privacy and fairness were part of the plan. Individuals saw only their own results. Managers saw team rollups. Items used plain language and real job cases, not trick questions. Feedback pointed to the right rule and a quick fix. If someone moved to a new role, HR data updated the learning bundle so they only saw checks that fit the work.

These controls did more than satisfy auditors. They built confidence across the business. Staff knew the standards. Managers had clear signals. Compliance had a complete, accurate trail. When rules changed, the bank could prove that people learned the change and used it in practice.

Lessons Learned Help Executives and L&D Teams Scale Auto-Generated Assessment Programs

Here are the takeaways that helped this Commercial Banking Unit scale auto‑generated assessments without slowing the business. They keep the work simple, link learning to the numbers leaders care about, and protect trust with clear rules and proof.

• Start with one product and one risky step to prove value fast and keep scope tight
• Define a shared tag set for product line, process step, and policy version so items line up with work and data joins stay clean
• Use blueprints that mirror the workflow and weight the tasks that drive most errors
• Keep checks short with three to five questions and a target of five minutes or less
• Give clear feedback that links to the exact policy page or job aid so people can fix gaps right away
• Send all results to the Cluelabs xAPI Learning Record Store and use live views for managers and subject matter experts
• Join LRS data to BI nightly so mastery and recency show up next to cycle time and exceptions
• Gate only what matters by requiring passes for high‑risk steps and new policy versions
• Schedule refreshers with spaced follow‑ups and rechecks when days since last pass cross a set mark
• Make managers owners of coaching with daily cues pulled from the top missed items
• Treat the item bank as a product with version control, a change log, and regular cleanups of weak questions
• Build trust with role‑based access, simple language, and views that show people only what they need

A few pitfalls are common and easy to avoid if you plan ahead:

• Overtesting creates noise and fatigue, so keep the cadence tight and relevant
• Untagged items break analytics, so make tags required fields in authoring
• One‑time launches go stale, so refresh items when policies change and retire outdated content
• Vanity metrics like completions hide gaps, so focus on mastery, recency, and impact on work
• Shadow processes emerge without governance, so define who approves, publishes, and audits
• Late data integration delays insight, so set up the LRS export and BI join before a wide rollout

A simple 90‑day plan helps teams get started and learn fast:

1. Pick one product and map the top three error‑prone steps
2. Set tags and pass thresholds, then configure the Cluelabs LRS
3. Generate questions, run SME review, and publish a small bank
4. Pilot with two teams, embed checks in the flow, and gather feedback
5. Turn on nightly exports to BI and build a basic mastery‑to‑metrics view
6. Tune items, add targeted nudges, and document the change process
7. Expand to the next product using the same blueprint and tags

The big lesson is simple. When assessments mirror the work, the LRS captures clean data, and BI shows the link to cycle time and exceptions, training stops being a cost center and starts to drive performance. Executives get evidence. Teams get timely coaching. Clients feel the speed and quality in every file.

Is an Auto-Generated Assessment and LRS Approach the Right Fit

In Commercial Banking Units, complex products, frequent policy updates, and many handoffs create delays and rework. In the case we explored, auto-generated quizzes and exams turned dense policies into short checks that matched real tasks. Each item carried tags for product line, process step, and policy version. The Cluelabs xAPI Learning Record Store captured every attempt and fed live views for managers, plus nightly exports to business intelligence. Leaders saw where skills lagged, coached fast, gated high-risk steps, and showed a clear correlation between mastery, cycle time, and exception rates. The audit trail supported compliance and gave confidence that people were using the latest rules.

If you are considering a similar path, use the questions below to test fit and surface the conditions you need for success.

1. Do we have a measurable pain in cycle time and exception rates that varies by product and step
   Why it matters: Clear pain creates urgency and a business case. This approach pays off most where delays and rework are visible and costly.
   Implications: If the process is stable and issues are rare, a lighter solution may be enough. If pain is real and uneven, targeted micro-assessments can move the needle.
2. Can we define a shared tagging model for product line, process step, and policy version
   Why it matters: Tags connect learning to the work. They power dashboards, coaching, and fair comparisons across roles and teams.
   Implications: If you cannot agree on tags, start with one product and a few steps to build a simple model. Without tags, analytics will be noisy and hard to trust.
3. Do we have the data plumbing to send assessment records to an LRS and join them to BI while meeting security and privacy needs
   Why it matters: The insights come from linking mastery and recency to cycle time and exceptions. An LRS such as the Cluelabs xAPI Learning Record Store makes that link possible.
   Implications: If integrations, access controls, or data ownership are unclear, plan a phased rollout. Define who owns the feed, what fields are shared, and how you protect personal data.
4. Will frontline teams and managers make time to use micro-checks and coaching in the flow of work
   Why it matters: Short checks and targeted coaching drive behavior change. Without adoption, the program becomes another dashboard that no one uses.
   Implications: If teams lack time or authority, redesign a few checkpoints and give managers simple cues. Build habits with five-minute huddles and readiness gates for high-risk steps.
5. Are we ready to govern and maintain the item bank with SME review, version control, and audit trails
   Why it matters: Quality and trust depend on accurate items and clear ownership. Governance keeps content current and defensible for audits.
   Implications: If SME time is scarce, create a small editor pool, set a change log, and review high-risk items first. Use version tags and readiness rules to prove who learned what and when.

If you answered yes to most questions, start with a 90-day pilot. Pick one product, tag three error-prone steps, connect the LRS to BI, and give managers clear coaching cues. If not, use the questions to close gaps in tagging, data access, manager habits, and governance before you scale.

Estimating Cost And Effort For An Auto-Generated Assessment And LRS Program

This estimate focuses on what it takes to stand up auto-generated quizzes and exams, connect them to the Cluelabs xAPI Learning Record Store, and link results to BI views of cycle time and exception rates. The mix below reflects a practical first-year plan for a Commercial Banking Unit. Your totals will shift with team size, in-house capabilities, and the breadth of products and process steps you cover in phase one.

Discovery and planning – Align stakeholders on goals, target products and steps, metrics, and success criteria. Define scope for a 90-day pilot and outline the path to scale.

Solution and assessment design – Build blueprints that mirror the workflow, define a shared tagging model (product line, process step, policy version), and set mastery thresholds and readiness gates.

Content production – Use AI to draft question variants from policies and job aids, have SMEs review and approve, and create a small set of micro-lessons for the most-missed steps. Package items for delivery and xAPI tracking.

Technology and integration – Configure the Cluelabs xAPI LRS, instrument assessments to send xAPI, stand up nightly exports, and build BI dashboards that display mastery and recency next to cycle time and exceptions.

Data and analytics – Define the data model, join keys, and privacy rules. Run initial correlation views and agree on how managers will use the signals for coaching.

Quality assurance and compliance – Perform item quality checks, UAT for flows and dashboards, accessibility reviews, and policy/legal checks on high-risk items.

Pilot and iteration – Run a focused pilot, enable managers, support learners, and iterate on confusing items and dashboards based on real use.

Deployment and enablement – Create communications, job aids, and train-the-trainer sessions. Provide huddle templates so managers act on the data in daily routines.

Change management and governance – Stand up ownership for the item bank, a change log, version control, approval workflow, and a tagging dictionary so content stays accurate and defensible.

Year 1 support and maintenance – Administer the LRS, refresh items as policies change, and keep BI views healthy. Budget for SME spot checks on updated items.

Assumptions for this budget:

• Phase-one scope: 2 products, 8 high-impact process steps, about 300 assessment items
• Audience: about 200 frontline and operations staff plus managers
• Pilot in 12 weeks, then scale using the same patterns
• Rates shown are illustrative and can be replaced with your internal or vendor rates
• LRS subscription is a budgetary placeholder; confirm with the vendor. Small pilots may fit a free tier

Cost Component	Unit Cost/Rate (USD)	Volume/Amount	Calculated Cost (USD)
Discovery and planning — Project management	$120/hour	40 hours	$4,800
Discovery and planning — Instructional design	$100/hour	24 hours	$2,400
Discovery and planning — SME participation	$150/hour	12 hours	$1,800
Solution and assessment design — Instructional design	$100/hour	40 hours	$4,000
Solution and assessment design — Learning technologist/developer	$130/hour	16 hours	$2,080
Solution and assessment design — SME review	$150/hour	16 hours	$2,400
Solution and assessment design — Data engineer	$140/hour	8 hours	$1,120
Content production — Question drafting (AI-assisted) by ID	$100/hour	90 hours	$9,000
Content production — SME item review and approvals	$150/hour	71 hours	$10,650
Content production — Micro-lessons by ID	$100/hour	18 hours	$1,800
Content production — Packaging by developer	$130/hour	6 hours	$780
Technology and integration — Cluelabs xAPI LRS subscription (placeholder)	$1,200/year	1 year	$1,200
Technology and integration — LRS setup and configuration	$130/hour	12 hours	$1,560
Technology and integration — xAPI instrumentation of assessments	$130/hour	36 hours	$4,680
Technology and integration — Nightly export to BI (data engineer)	$140/hour	32 hours	$4,480
Technology and integration — BI dashboards (analyst)	$120/hour	40 hours	$4,800
Data and analytics — Data model and join keys (data engineer)	$140/hour	16 hours	$2,240
Data and analytics — Correlation and visuals (BI analyst)	$120/hour	24 hours	$2,880
Data and analytics — Privacy and governance review	$95/hour	10 hours	$950
Quality assurance and compliance — Item QA	$95/hour	24 hours	$2,280
Quality assurance and compliance — UAT for flows and dashboards	$95/hour	16 hours	$1,520
Quality assurance and compliance — Accessibility review	$95/hour	8 hours	$760
Quality assurance and compliance — Policy/legal check on high-risk items	$95/hour	12 hours	$1,140
Pilot and iteration — Manager enablement sessions	$110/hour	10 hours	$1,100
Pilot and iteration — Live pilot support	$90/hour	40 hours	$3,600
Pilot and iteration — Content and tech iteration (ID)	$100/hour	16 hours	$1,600
Pilot and iteration — Content and tech iteration (developer)	$130/hour	12 hours	$1,560
Pilot and iteration — Dashboard iteration (BI)	$120/hour	12 hours	$1,440
Pilot and iteration — Data fixes (data engineer)	$140/hour	8 hours	$1,120
Deployment and enablement — Communications plan	$110/hour	12 hours	$1,320
Deployment and enablement — Job aids	$100/hour	12 hours	$1,200
Deployment and enablement — Train-the-trainer	$110/hour	10 hours	$1,100
Deployment and enablement — Manager huddle templates	$110/hour	6 hours	$660
Change management and governance — Governance charter	$110/hour	12 hours	$1,320
Change management and governance — Compliance participation	$95/hour	6 hours	$570
Change management and governance — SME lead participation	$150/hour	6 hours	$900
Change management and governance — Tag dictionary (ID)	$100/hour	8 hours	$800
Change management and governance — Tag dictionary (data engineer)	$140/hour	8 hours	$1,120
Change management and governance — Approvals workflow setup	$130/hour	8 hours	$1,040
Change management and governance — Risk assessment	$95/hour	6 hours	$570
Year 1 support and maintenance — LRS admin and monitoring	$90/hour	100 hours	$9,000
Year 1 support and maintenance — Item refreshes (ID)	$100/hour	72 hours	$7,200
Year 1 support and maintenance — SME review for updates	$150/hour	36 hours	$5,400
Year 1 support and maintenance — BI upkeep	$120/hour	48 hours	$5,760
Year 1 support and maintenance — Data engineering upkeep	$140/hour	48 hours	$6,720
Estimated Total (Year 1)			$124,420

Effort and timeline at a glance: The initial build and pilot typically require about 750 to 800 hours across roles over 10 to 12 weeks, followed by 4 to 6 weeks to scale across additional teams using the same patterns. Year-one support assumes modest policy churn and a handful of dashboard tweaks.

Levers to lower cost:

• Start with one product and three to five steps to keep content volume small
• Use a free LRS tier during the pilot if activity volume allows
• Adopt a strict tagging dictionary up front to avoid rework in BI
• Target micro-lessons only to high-miss items
• Blend roles if you have multi-skilled staff who can handle ID and LRS setup

Where to invest more:

• Deeper integration if you want readiness gates enforced in workflow tools
• Richer analytics if you need advanced segmentation or predictive cues
• Extra SME capacity during heavy policy changes

Use this model to seed your internal budget. Replace rates with internal costs, adjust volumes for your scope, and confirm tooling costs with vendors. Add a 10 to 15 percent contingency for policy spikes and integration surprises.