
⏱ 2-minute read · open “Read more” for the details
Payment projects rarely fail because nobody saw the problem. They fail because the problem took too long to reach someone who could act on it. In payments, that delay is expensive: network deadlines don’t move, regulators don’t wait, and money that goes out wrong is hard to get back.
In payment projects, problems must reach the people who can fix them faster than money moves. This post explains how to raise bad news early, clearly and without blame.

The dark blue box in the middle is the main idea: bad news must travel faster than money. The gray boxes on the left show the problem: why people stay quiet, and what the delay costs. The boxes on the right show where bad news hides and, in blue, what the best teams do. The goal: shorten the time from knowing to acting.
Someone always knew
Meet Raj, a developer. He sees the FedNow certification test failing, and the network’s test window closes soon. He keeps quiet for now.
- When a launch slips, the review almost always finds that someone knew weeks earlier.
- A project manager saw the ISO 20022 plan slipping. A tester saw sanctions screening slow down at peak.
- The problem wasn’t hidden. It just travelled too slowly.
Read more: Someone always knew
I’ve seen this pattern again and again in payments delivery. When a launch slips or a release goes wrong, the review almost always finds the same thing: someone knew weeks earlier.
- A developer noticed that the FedNow or RTP certification test was failing, and the network’s test window was closing.
- A project manager saw the ISO 20022 migration plan becoming unrealistic against a fixed network deadline.
- A business analyst knew the requirement for returns and exceptions wasn’t clear.
- An operations analyst saw the same reconciliation break come back every morning.
- A tester saw sanctions screening slow down under peak volume, putting the instant payment deadline at risk.
The signal was there. It just didn’t move. It sat with the person who spotted it, while the problem quietly grew.
Why good people stay quiet
Raj isn’t careless. He stays quiet for three very human reasons.
- He thinks he can fix it first.
- He doesn’t want to cause alarm.
- He isn’t sure it’s his place to say.
- In payments, waiting is costly: deadlines don’t move, and instant payments can’t be pulled back.
Read more: Why good people stay quiet
Nobody escalates immediately. Not because they don’t care, but for three very human reasons:
- They think they can fix it first. Raising it feels like admitting defeat, so they try one more workaround or one more test run.
- They don’t want to create unnecessary concern. In a bank, the word “risk” can trigger compliance reviews and senior attention. It might sort itself out, so why start that?
- They’re unsure it’s their place. “Surely the product owner already knows about the network deadline.” Often, they don’t.
Each reason makes sense on its own. Together, they make bad news travel slowly.
Why the delay costs more in payments. In most software, a late problem means a late feature. In payments, it can mean:
- A missed network or regulatory date. Scheme mandates (required changes set by card networks and payment systems), certification windows and cut-off times are fixed. Miss one and you can wait months for the next slot.
- Money that has already moved. Instant payments are final. Once a wrong payment settles, you can only ask for it back, and the other bank can say no.
- Customers and regulators finding out first. A failed payroll or a stuck payout reaches the customer in minutes, and the regulator soon after.
On day one, a failing certification test can be solved with a quick call to the network or the vendor. A month later, the only options left are delaying the launch, cutting scope or going live with a known risk. By the time the problem reaches the decision-maker, the easy options are gone.
Where bad news hides in payments projects
Raj’s failing test is one of nine places where problems hide longest in payments projects.
- Testing gaps: thin unit tests, missing acceptance criteria, untested peak volume.
- Hand-overs: unsigned interface specs, other teams’ FX changes, tickets bouncing between support levels.
- Slow-burn risks: Kafka lag creeping up, certificates near expiry, open-source flaws past their fix date.
Read more: Where bad news hides in payments projects
In my experience, nine places hide problems longer than any others. Each one looks fine on a status report until it suddenly isn’t.
1. Unit testing. Low or shallow unit test coverage feels like a developer detail, so nobody raises it. But payment logic is full of edge cases: amounts with too many decimals, currency rounding, cut-off times, duplicate submissions, retries after a timeout. When those cases aren’t tested at the unit level, defects show up late in system or user acceptance testing, or in production with real money.
- Warning sign: coverage reported as a single number, with no view of which payment scenarios are covered.
- Raise it when: a critical path (debit, credit, status update, return) has no unit tests, or tests are skipped to hit a date.
2. Requirement coverage and clarity. Payment requirements usually cover the happy path well and the exceptions poorly. What happens when the network doesn’t answer? When a return arrives for a payment already refunded? When the beneficiary name doesn’t match? If those answers aren’t written down, developers guess, and testers test their own guesses.
- Warning sign: requirements with no acceptance criteria for rejects, returns, timeouts and statuses, or no link (traceability) from each requirement to its test cases.
- Raise it when: a story enters a sprint with open questions, or testers find behavior that no requirement describes.
3. Downstream system dependencies. A payment touches many systems: core banking, the ledger, sanctions screening, fraud, notifications, reporting, the general ledger and the network gateway. Another team often owns each one, with its own release plan. A delay in any of them can stop your launch, even when your own work is done.
- Warning sign: an interface spec that isn’t signed off, a test environment that isn’t ready, or a downstream team that hasn’t planned your change into its release.
- Raise it when: a dependency has no confirmed date, or end-to-end testing can’t start because one system isn’t connected.
4. Monitoring, alerts and notifications. The most dangerous problems are the silent ones. A Kafka server (broker) or reader (consumer) slowly runs short of memory, consumer lag grows, and payment events pile up unprocessed. Nothing crashes, so nobody notices. Meanwhile, an alert that was never set up, or was routed to an old mailbox, doesn’t fire. And the email notifications that should tell customers and operations a payment failed or is on hold quietly stop going out. By the time someone complains, hours of payments are stuck and the instant payment deadline has long passed.
- Warning sign: Kafka memory, disk or consumer lag that is creeping up week by week; alerts that fire so often everyone ignores them; no one checking whether notification emails were actually delivered.
- Raise it when: consumer lag or memory crosses an agreed threshold, an alert has no named owner, or a failed or held payment didn’t produce the customer or ops email it should have.
5. Performance and high-volume payment dates. A system that is fine on a normal Tuesday can fall over on payroll day, month-end, quarter-end, tax deadlines or the busiest shopping days of the year. Response times creep up release by release, but each change looks small, so nobody calls it out. Then volume doubles on one morning, sanctions screening and posting slow down, instant payments start timing out, and batch files miss their cut-off.
- Warning sign: no performance test at expected peak volume, response times drifting up from one release to the next, or a release planned close to a known high-volume date.
- Raise it when: a performance test misses its target, peak volume isn’t known for the next big date, or a change goes live within days of a peak without being load-tested.
6. FX service updates. Cross-border payments depend on FX rates, and those services change more often than people expect: a new rate provider, a new feed format, new refresh times or cut-offs, new currency pairs, or new rounding and margin rules. If the payments team hears late, customers can be quoted one rate and charged another, or payments can fail when a rate is missing or out of date.
- Warning sign: FX changes planned by another team with no payments sign-off, no test of rate expiry and rounding, or no alert when a rate is stale.
- Raise it when: an FX provider or feed change has a date but no payments test plan, or quoted and booked rates don’t match in testing.
7. L1, L2 and L3 support handovers. In production, bad news travels through support levels: L1 (service desk and operations) sees the symptom, L2 (application support) investigates, and L3 (engineering and vendors) fixes the root cause. Each handover is a place where a problem can wait. A ticket sits in an L1 queue because nobody recognized it as a payment issue. L2 works around it for weeks without telling L3. L3 fixes the code but nobody updates the runbook, so the same incident returns.
- Warning sign: tickets bouncing between levels, no runbook for common payment failures, workarounds that become permanent, or no clear rule for when L1 must page L2 or L3.
- Raise it when: a payment incident has gone through more than one handover without an owner, or the same workaround has been used more than twice.
8. Software certifications. Payments software depends on certifications and sign-offs that expire on a fixed date. They include PCI DSS (security rules for anyone who handles card data) and the SWIFT (the secure network banks use to send payments abroad) security checklist sign-off, called the Customer Security Programme, or CSP. They also include SOC reports, network and vendor version certifications, and the security certificates (TLS and signing keys) that every connection to a network depends on. Expiry dates are known months ahead, yet they still catch teams out, because they sit in someone’s calendar rather than on the project’s risk list.
- Warning sign: no single list of certificates, attestations and vendor versions with expiry dates and owners; a vendor product nearing end of support.
- Raise it when: anything is within 90 days of expiry with no renewal plan, or a vendor version is going out of support.
9. OSS (open-source software) remediation. Payment systems are built on open-source libraries, and those libraries regularly get security fixes. A scanner flags a critical vulnerability, the team logs it, and the upgrade keeps losing to feature work. Each skipped upgrade makes the next one bigger and riskier, until an auditor or an attacker forces the issue.
- Warning sign: a growing backlog of open-source vulnerabilities, critical findings older than the agreed fix time, or libraries several major versions behind.
- Raise it when: a critical or high finding passes its fix deadline, or an upgrade is deferred to protect a release date.
What the best payments teams do differently
The best teams don’t avoid problems. They make bad news travel fast.
- A five-minute weekly risk update with three questions: what is at risk, what do we need from whom, and by when?
- A simple table: if you notice this, tell these people, by this time.
Read more: What the best payments teams do differently
The best payments delivery teams I’ve worked with don’t eliminate problems. They make bad news travel fast. Three habits make the difference.
1. A short weekly risk update. Five minutes, the same three questions every week:
- What’s at risk: a date, a dependency, a control or customer money?
- What do we need, and from whom: the network, a vendor, compliance, operations?
- By when, before it gets harder to fix?
Keep it in one shared place, such as a RAID log (Risks, Assumptions, Issues, Dependencies), so nothing lives only in someone’s head. Put every fixed outside date at the top: network certification windows, scheme mandates and regulatory deadlines.
2. A culture where an early flag is rewarded. Thank the person who raises a risk, even when it turns out to be nothing. A false alarm costs minutes. A missed warning in payments can cost a network date, a customer’s money or a regulatory finding.
3. Leaders who fix the problem, not the messenger. The first reaction to bad news sets the rule for the whole team. Ask “what do you need?”, never “why didn’t this work?” Blame teaches people to hide problems, and in a regulated business, hidden problems become audit findings.
A simple escalation guide for payments teams:
| If you notice… | Tell | By when |
|---|---|---|
| Payments failing, stuck or duplicated in production | Operations lead and product owner | Immediately |
| A risk to sanctions (bans on dealing with certain people, companies or countries), AML (anti-money-laundering checks) or other compliance controls | Compliance and the product owner | Immediately |
| Kafka memory, disk or consumer lag rising, or payment events not being processed | Platform or SRE (engineers who keep live systems reliable) on-call and the operations lead | Immediately |
| A payment incident passed between L1, L2 and L3 with no clear owner | L2 lead and the incident manager | Immediately |
| An alert that didn’t fire, or a customer or ops email notification that wasn’t sent | Platform or SRE on-call and the product owner | Same day |
| A performance test missing its target, or a release close to a high-volume payment date | Tech lead, operations lead and product owner | Same day, and before the release is approved |
| An FX provider, rate feed or cut-off change without a payments test plan, or quoted and booked rates that don’t match | Product owner and the FX service owner | Same day |
| A reconciliation break that isn’t explained | Operations and Finance | Same day |
| A slipping network certification, scheme date or vendor dependency | Delivery lead and product owner | Same day |
| A downstream system without a confirmed date, signed-off interface or ready test environment | Delivery lead and the downstream team’s lead | Same day |
| A critical or high open-source vulnerability past its fix deadline | Security lead and tech lead | Same day |
| A certificate, attestation or vendor version within 90 days of expiry with no renewal plan | Security or compliance owner and product owner | Same week |
| A workaround used more than twice, or a missing runbook for a common payment failure | L2 lead and the L3 engineering lead | Same week |
| A critical payment path with missing or skipped unit tests | Tech lead and QA lead | Before the code is merged |
| A requirement for returns, exceptions or statuses that isn’t clear, or has no test coverage | Product owner and QA lead | Before work starts on it |
| A problem you’ve tried to fix for more than a day | Your lead | Next stand-up |
Shorten the time between knowing and acting
Back to Raj. If he speaks up on day one, the team still has weeks to fix the test.
- The goal isn’t more meetings or reports.
- Measure the gap between spotting a risk and someone acting on it.
- If that gap shrinks, your team is getting healthier.
Read more: Shorten the time between knowing and acting
The goal isn’t more meetings or more reports. It’s reducing the time between knowing and acting.
Measure that gap, even roughly. When a risk is raised, note when it was first spotted and when someone with authority acted on it. If that gap is shrinking, your team is getting healthier, whatever the status report says.
Payments move in seconds now. Instant payments settle in under a minute, 24 hours a day. Our bad news should move at least as fast. Problems will always happen. The teams that deliver are the ones where bad news reaches the right person while the easy options are still on the table.
How quickly does bad news travel in your payments team, and what’s one thing that would make it faster?
Working on a payments project?
I help banks and fintechs deliver real-time payments, ISO 20022, and AI-driven AML and compliance change, from strategy to go-live.
Connect on LinkedInSee how I can help