Summary: What often looks like a technical hiccup is actually a missed opportunity to understand why users disengage, why automation lacks clarity, and how emotional intelligence is absent from most user-facing systems. The JSON error message about “insufficient account balance” isn’t just a bug. It’s a blind spot—a moment when the system fumbles its side of the conversation. Instead of acknowledging the user's reality, it spits out code like a machine talking to itself. This post unpacks what that silence costs us and how to do better.
When Systems Fail to Tell a Story
If someone hits a wall when trying to make a payment or access a service, and all they see is:
{
"error": {
"code": "BALANCE_INSUFFICIENT",
"message": "Your current account balance is insufficient for this transaction."
}
}
…then the system hasn’t just failed to complete a financial transaction—it has failed to communicate. There's no story, no frame, no pathway forward. The user is left out in the cold, wondering what went wrong, what to do next, and whether anyone even cares. There’s no narrative bridge. There’s just rejection.
Why Flat Error Messages Backfire
Error messages are one of the most overlooked touchpoints in user experience. When they're shallow, they violate reciprocity—we ask for engagement without clarity. They derail momentum, especially if a user feels embarrassed at having no funds or confused because the balance should cover it. That tiny JSON packet fails Blair Warren’s persuasion checklist on every count. It doesn’t encourage a dream, justify a failure, or show any empathy. There’s no human tone, no strategic pause, and no next step.
So why do developers write this way? Because these messages aren't designed for the customer, they're designed for debugging. They're artifacts of internal logic leaking into the public space. And to users? That’s noise. Worse, it's impersonal noise at a highly personal moment.
Let’s Mirror the Human Experience
What’s really happening here? Someone tried to pay. It didn’t work. Maybe they forgot to top up their balance, maybe they miscalculated, maybe something's wrong on your end. All they know is that access is shut down.
What if, instead of a flat JSON message, the response was something like:
“It looks like your payment didn’t go through because your account appears to be short. A lot of people forget to top up, and sometimes our systems get out of sync. Want to double-check your balance or use another payment method?”
Now you’ve mirrored a possible situation, justified a common failure, shown empathy, and offered a next step. You’ve made it safe to say, “No, I don’t want to pay now” or “Wait—can I fix this?” You’ve invited further conversation instead of dropping a steel gate.
The Cost of Poor Communication in Transactional Systems
These communication lapses aren’t harmless. They erode trust. A poorly worded error message tells the customer: “You're not our priority.” That message costs you referrals, renewals, and goodwill.
And let’s not ignore psychology. Many people feel a deep emotional sting when told they can’t afford something—especially by a machine. When that message comes cold, it confirms a suspicion: “I’m failing.” That’s an emotional wound for which the company providing the message becomes responsible—even if unintentionally.
Invite Dialogue, Even in Failure
Chris Voss makes a brilliant point in Never Split the Difference: When someone says “No,” that’s not the end—it’s a doorway. But only if the tone makes room for it. A “No” to a transaction might just mean “Not now,” or “Help me understand what went wrong.” Your message can create that space.
Ask yourself: Is your system encouraging users to respond, fix, or try again? Are you giving them a reason to stay engaged, or are you pushing them back into frustration and silence? Strategic empathy starts with respecting people enough to talk like humans—even when things fail.
Designing Better Error Experiences
Making error messages work harder doesn’t require magic. It just requires rethinking their role. Here’s a structured way to reframe these moments:
- Empathize: Mirror the pain. Acknowledge what the user might be feeling (“Looks like something went sideways.”)
- Clarify: Explain what’s going on, in plain language (“We couldn’t process the payment because the balance appears too low.”)
- Guide: Lay out the options (“You can try again, update billing, or contact support—whatever works.”)
- Invite: Use strategic questions to keep the conversation going (“Would you like to switch payment methods or review your account?”)
This is a chance to be more than functional. It’s a rare moment to reaffirm your brand and moral authority as a trustworthy operator—one that sees people, not just transactions.
Rewriting the Story Inside the Silence
Let’s revisit the original error one more time:
{
"error": {
"code": "BALANCE_INSUFFICIENT",
"message": "Your current account balance is insufficient for this transaction."
}
}
Now imagine you're the one receiving that. What dream just got interrupted? What suspicion just got confirmed? What fear just came rushing back? Your customers carry all this behind the screen—and pretending their emotional state doesn’t exist because “it’s just a transactional message” is what turns a hiccup into a lost account.
Your system, your copy, your UX—they all need to show the user: “You're seen. You've got options. We’re still in this together.”
A final thought: Data formats don’t tell stories. Humans do. If your system speaks in a foreign language at moments of failure, you're breaking the conversation. And in business, broken conversations are expensive. That JSON error may not tell a story, but it writes a line in the story your customer will tell others—good or bad. So the real question is: What part do you want your company to play in that story?
#UserExperience #CustomerCommunication #ErrorDesign #MarketingPsychology #HumanCenteredUX #BehavioralDesign
Featured Image courtesy of Unsplash and Markus Winkler (-q8MdTL2998)