RBL Bank wanted to launch its first UPI-powered credit card payment experience. My challenge was designing a journey customers could trust from the very first transaction — on a platform that had never offered this capability before.
I led end-to-end design of RBL Bank's first UPI payment experience for credit card customers — from blank canvas to shipped product. Before this, customers could only pay their credit card bill online via internet banking or another bank's debit card. UPI wasn't an option. Three distinct payment journeys. Seven-plus edge cases. Every failure state. And one question that had to be answered on every screen: did my money go through?
Before this project, RBL Bank credit card customers had limited options for paying their bill online — internet banking or another bank's debit card. UPI, the payment method most of them used for everything else in their daily lives, wasn't available on the RBL website at all.
The business opportunity was clear. The customer need was urgent. What wasn't clear was the complexity hiding inside what sounded like a simple request: "Add UPI as a payment option."
With UPI becoming India's preferred digital payment method — processing over 10 billion transactions a month by 2022 — customers increasingly expected credit card payments to be as seamless as everyday UPI transfers. Paying a credit card bill by calling a helpline felt like a generation behind. The business saw a narrow window to build this capability before it became a competitive liability.
Before designing anything new, I needed to see exactly what customers were working with. Here's what existed — and what this project replaced it with.
Before this project, customers could only pay through Net Banking and Debit Card via third-party gateways. This project introduced a native UPI payment option while preserving the existing payment experience — letting customers use a faster, more familiar payment method without disrupting workflows they already knew.
"The existing payment journey depended heavily on third-party gateways — limiting ownership of the customer experience and excluding the fastest-growing payment ecosystem in India."
Two payment methods, both routed through third-party gateways the bank didn't own.
Customers had to route through RBL's net banking or a third-party gateway (BillDesk/Razorpay) just to pay their own credit card bill. Every extra redirect was a moment for a customer to abandon the payment — and a moment RBL didn't control.
This path was powered entirely by Razorpay, accepting any bank's debit card. Functionally it worked — but RBL had zero ownership of the payment relationship, the data, or the experience at the exact moment money changed hands.
Instead of replacing the existing payment experience, we extended it. The goal was to preserve familiarity, reduce learning effort, introduce a modern payment method, minimize engineering scope, and keep existing customer behavior intact — all at once.
Instead of redesigning the entire modal, I introduced a dedicated UPI tab inside the existing payment navigation. Customers immediately understood the interface because nothing familiar disappeared — the experience evolved instead of being replaced.
A standalone UPI flow could have been more "on-brand" for the new method, but it would ask every customer — including the ones who'd used Net Banking for years — to relearn a payment interaction. That cost outweighed the benefit.
Payment moments are trust moments. Introducing unfamiliar UI at the exact point money changes hands increases hesitation and abandonment — the opposite of what a faster payment method should do.
Extending the existing tab structure meant reusing the modal's routing, validation, and state-handling logic instead of building a parallel system — a smaller, lower-risk scope that shipped faster.
Progressive enhancement let the business ship the highest-priority capability — UPI — without a large-scope redesign project competing for the same engineering quarter.
Customers recognized the extended navigation instantly — no new pattern to remember.
UPI followed the same tab, layout, and CTA conventions as every other payment method in the modal.
The core experience worked exactly as before; UPI layered on top without breaking anything.
UPI details only appear once a customer selects that tab — no added complexity for everyone else.
Pay Now stayed the clear primary action; the new option never competed for attention with existing ones.
Customers keep full choice between Net Banking, Debit Card, and UPI — nothing was taken away.
Primary actions (Pay Now, Know More) kept consistent size and position across every tab for fast, confident targeting.
Reusing an existing mental model meant zero onboarding cost for a brand-new payment method.
UPI slotted into the existing left-nav hierarchy exactly where customers would look for a new payment option.
Understanding what shipped was one thing. Understanding why users still hesitated at the moment of payment required getting into their heads directly.
Two weeks of competitive analysis across GPay, PhonePe, CRED, Paytm, and five banking apps — supplemented by support call log review and stakeholder interviews. The pattern was the same everywhere. This wasn't a feature problem. It was a trust problem.
"Did my payment go through?"
That's the only question users are asking during a payment. Design response: every screen had to answer this question — proactively, not reactively.
Trust breaks in the 30–90 second gap after QR scan.
This silent window — between scanning and confirmation — is where anxiety spikes. Design response: fill the gap with a visible timer and clear progress context.
Clarity beats feature richness, every time.
Apps with fewer features but immediate, specific feedback outperformed richer apps with ambiguous states. Design response: ruthlessly simplify each screen to one job.
Zero-balance was the #1 avoidable support trigger.
Customers with ₹0 outstanding saw blank amounts, assumed the system was broken, and called support. Design response: proactive state explanation — before the customer wonders.
Blended Credit Card and STPL UI causes wrong payments.
Customers couldn't distinguish between products in a shared UI. The consequences were dispute-level errors. Design response: dedicated journeys, not a toggle.
Slow validation errors feel like bank failures.
A 3-second server-side response to an invalid card number felt like a system error. Design response: client-side validation, immediate and specific — before any API call.
"Payment design is not about the transaction. It's about the confidence the customer feels while making it."
The findings revealed something unexpected. We weren't designing one payment journey. We were designing three — and each one had completely different customer expectations.
This section is a placeholder — ready for the real concepts explored during this project, not yet filled in.
This section is a placeholder — ready for real version history and feedback, not yet filled in.
What looked like a single payment screen was, beneath the surface, three distinct product experiences — each with different customers, different financial rules, different emotional stakes. Designing them as one would have been the easiest mistake to make, and the most expensive one to fix.
"Three journeys. One entry point. Zero margin for a customer ending up in the wrong one."
Credit Card make a payment · Zero outstanding · STPL outstanding · Success, error, invalid, failed, pending states.
Credit Card Journey · Zero outstanding · STPL outstanding — responsive design from the start, not a mobile afterthought.
Designing the happy path was relatively straightforward. The real product thinking emerged when we had to make the hard calls — the ones with real trade-offs.
Early in the project, we faced a foundational technology decision that would shape the entire payment experience. It wasn't a visual design choice. It was a product architecture choice with downstream consequences for trust, conversion, and technical risk.
The payment had to be initiated via UPI, but there were two technical paths. Deep linking felt like the smoother UX — one tap, UPI app opens, payment completes. But the platform constraints were significant.
Option A: UPI deep linking — automatic app redirect on tap.
Option B: QR code display — customer scans from any UPI app on any device.
Deep linking required native app API integrations that our responsive web platform couldn't guarantee across Android, iOS, and browser combinations. A broken deep link mid-payment is more trust-damaging than a QR. QR is universal — no integration dependency, no device-specific failures.
QR code. Lower technical risk, universal compatibility, and — critically — QR enables the 5-minute countdown timer that deep linking can't support. That timer became one of the most important trust signals in the entire experience.
The screen this decision produced — with the countdown timer that deep linking could never have supported.
"The best design decisions at this project weren't made in Figma. They were made in a room with engineering, asking: what can we actually trust to work for every user, on every device, every time?"
With the architecture decided, it was time to design the core experience — four screens, each with a single job, and no room for ambiguity.
All three journeys are accessible from the starting screen. Click through to experience how the payment flow, edge cases, and failure states work together as a connected product.
You can also explore this prototype directly in Figma.
Open interactive prototype ↗Each screen had exactly one job. The design removed everything that didn't serve the customer's most urgent need at that moment — and added everything that reduced uncertainty. Screens below support the story. They don't tell it.
UPI QR expires in 5 minutes — invisible to the user. Refreshing the page voided the entire session and required starting over.
Visible countdown timer from the moment QR appears. "Do not refresh" warning in context. Download + share for device-switchers — eliminating the need to refresh.
Customers knew exactly how long they had. Urgency without panic. The silent waiting gap between scan and confirmation now had a voice.
Complete receipt. Amount, Payment ID, timestamp. Nothing left to wonder about.
Payment ID preserved. "Allow 24 hours." Wait, but don't panic — the bank has it.
Dispute evidence preserved even at the worst moment. The failure screen became a self-service recovery tool.
Design decision: All three states use identical layout — same card, same fields, same position. Only the icon color and heading change. This consistency means customers never have to learn a new UI when things go wrong. The structure is a trust signal.
Designing the happy path was the straightforward part. The real product thinking began when customers didn't follow it.
In financial products, edge cases aren't rare — they're predictable. The quality of a payment product isn't measured by how it handles success. It's measured by how it handles everything that can go wrong before, during, and after.
Zero-balance customers were the single largest driver of avoidable support calls in the legacy system. They arrived ready to pay. They saw amounts showing ₹0.00 with no explanation. They assumed the system was broken. They called the helpline. The helpline told them their balance was zero. The customer felt confused, then embarrassed.
The fix wasn't a backend change. It was a UX decision: explain the account state before the customer has to wonder about it. A graceful exit, not a dead end.
"Good design isn't always helping users take action. Sometimes it's helping them understand why no action is needed."
Customers begin exactly as they would in a standard payment. No indication that anything is different — the surprise arrives on the next screen.
"Please ignore if already paid." Six words that replaced a support call. Instead of a blank dead end, an explanation and a dignified exit.
When a customer tries to pay above ₹1,00,000 via UPI, the default experience in most apps is a cryptic decline — after the QR has been generated, possibly scanned, and the customer is already waiting for confirmation.
We surfaced the constraint before QR generation: clear RBI language, the specific limit, and what the customer should do instead. A trust-building detour rather than a trust-breaking dead end.
"Mobile number is invalid." Client-side, immediate, specific. No API call. No 3-second wait that feels like a server failure.
"Credit card number is invalid." Same modal pattern. Consistent behaviour is a trust signal — customers learn once, apply everywhere.
"Fetching your details." A loading screen that explains itself. Replaces the blank white delay that customers assumed was a crash.
An illustrated error state with plain language — "Oops! Something went wrong. Please try again later." No technical codes, no red alarms, no blame. Empathy as a design decision. The illustration signals that this is a known, handled state — not a broken experience.
"A good error screen tells the user three things: what happened, that it's not their fault, and what to do next."
Edge cases covered. But we still had to solve the hardest product architecture decision of the project — whether STPL deserved its own experience entirely.
Unlike standard credit card payments, STPL customers had completely different repayment expectations, different account formats, and different validation requirements. Reusing the standard payment experience would have created persistent confusion and increased support dependency — the exact problem we were trying to solve.
The question wasn't how to style a toggle between the two products. The question was whether STPL deserved its own journey — its own entry point, its own fields, its own rules.
It did. And we built it.
A separate tab creates a hard mental boundary. Customers know which product they're paying before entering a single digit.
No minimum due option — because STPL doesn't support it. The UI reflects the product's actual rules, not a copy-paste of the credit card flow.
"The best decision in this section wasn't about how the screens looked. It was deciding that STPL needed its own journey at all."
In week two, an engineer mentioned offhand that UPI QR codes expire after 5 minutes during an API response discussion. That single comment became one of the most important UX decisions in the product — a visible countdown timer that dissolved the highest-anxiety moment in the entire payment journey. That's what happens when design is present in engineering conversations, not just at handoff.
Engineering mapped all available API fields in week 1 — including which payment status responses were synchronous and which were asynchronous. This determined the pending state design and recovery path before any wireframe was drawn.
Weekly design-engineering syncs on validation rules before any screen went to high-fidelity. QR download required a new API endpoint — scoped and built in sprint 3 after the design case was made with user context.
QA surfaced two undocumented edge states during UAT: a session hang when the bank API timed out mid-load, and a race condition on the pending → failed state transition. Both were designed and resolved before release.
Participated in all three UAT cycles across all three journeys. Raised 4 UI-level defects found during live testing that weren't in the written spec. Design was present through delivery — not just at handoff.
Before this shipped, RBL Bank credit card customers could only pay their bills online via internet banking or another bank's debit card. UPI — the payment method they used for everything else — wasn't an option on the RBL website at all. After this shipped, it was.
Three months after launch, the customer care team described the change in support patterns: "We're getting fewer calls about payment issues. And when customers do call, they already understand what happened — they're asking a specific question, not reporting that the page looks broken."
That second part mattered as much as the first. The zero-balance confusion and blank-screen panic that had driven the most avoidable calls were gone — not because of a backend fix, but because the UI finally explained what it knew.