Payment Gateway Questions & Answers

Ah, the classic UPI retry storm problem, one FD payment lags, and suddenly your system hammers the PSP 50 times like it owes you rent.

If your reconciliation engine is involved in posting or retrying UPI payments for term deposits, you’ve got to rate-limit and back off intelligently when response times get ugly.

Here’s how to handle it cleanly:

• Watch latency in real time

Your reconciliation service should be monitoring average UPI API response times from PSPs or payment gateways.

Once it crosses a threshold (say, >2 seconds for collect requests or >5 seconds for status checks), mark the PSP as degraded.

You can track this using a rolling 5-minute window:
if avg_response_time > 2s for last 20 calls:

 PSP_status = DEGRADED

• Switch to exponential backoff

Instead of retrying instantly, back off exponentially when in degraded mode.

Never let reconciliation keep hammering NPCI endpoints or gateway APIs — you’ll just make the latency worse.

• Use a per-category throttle for FDs

Term deposit openings are high-value and not time-sensitive like bill payments.

Throttle them harder — e.g. 2–3 retries max over 15 minutes.

Meanwhile, keep low-value UPI collections (like ₹100 bills) on a faster retry policy.

That means your logic should check something like:

if txn.category == TERM_DEPOSIT:

set_retry_policy(slow)

else:

set_retry_policy(normal)

• Pause retries globally if latency spikes across PSPs

If all your PSPs (Razorpay, Cashfree, PayU, etc.) are lagging at once, it’s probably an NPCI or bank switch issue.

In that case, trigger a global cooldown, stop retries for 5–10 minutes and show users a soft message like:

UPI networks are slower right now. Your FD payment will be retried automatically once things stabilize.

• Alert finance + ops teams

When throttling kicks in, send a Slack/email alert to finance or ops:

• UPI retries throttled for FD transactions
• Include metrics like current latency, pending transaction count, and next retry time.

That keeps everyone informed without manual digging.

• Resume normal retries automatically

When your average response time drops back below the threshold (say, <1.5s for 3 consecutive minutes),

mark the PSP as healthy again and restore normal retry intervals.

So after the 2025 UPI update, education fee payments and term deposits were moved into the high-value, permitted category, meaning NPCI and banks can now allow higher per-transaction limits (₹2L–₹5L) if the payment is tagged correctly.

If your billing system supports UPI for schools or universities, you can show real-time messages when the customer’s bank supports those higher limits.

Here’s how to wire that up:

• Detect the transaction category early

When the invoice or payment link is created, tag it as:

upi_category: EDUCATION_FEES

That category code is how NPCI and PSPs decide whether the higher limit applies.

If the backend already knows the payment is education fees, pass that in the UPI intent or collect payload.

• Query PSP / Bank capability in real time

Before showing the payment screen, ping your PSP or UPI SDK (

Razorpay, Cashfree, PayU, etc.) for the payer’s bank + PSP profile.

They usually return metadata like:

{ 

bank: HDFC Bank,

upi_limit: 500000,

category_supported: [EDUCATION_FEES, TERM_DEPOSIT]

}

If the category and limit match your transaction, boom eligible.

• Surface the message on the payment screen

When you detect eligibility, show a non-intrusive banner or toast right under the UPI option:

Good news!

Payments for education fees are eligible for higher UPI limits (up to ₹5,00,000) with your bank.

If the user isn’t eligible:

Your bank’s UPI limit is ₹1,00,000 per transaction. Try NetBanking or split your payment.

No one wants to hit Pay and watch it fail after 5 seconds.

• Cache the limit per bank / PSP

You don’t need to query NPCI every time.

Cache UPI limits per bank + category for a few hours.

• Show fallback recommendations

If the user’s limit is low, suggest next best options right on-screen:

You’ve hit your ₹1L UPI cap. Try splitting into smaller UPI transfers or use NetBanking.

Keeps checkout smooth without confusion.

• Optional: Add a soft eligibility check before QR render

If you’re using intent flow or dynamic QR, validate eligibility before generating the QR.

That saves unnecessary QR refreshes or collect failures.

Add a purpose code like TDOP, store it in your ledger + invoice metadata, and make sure every UPI collection carries it end-to-end — from payment initiation → ledger → GST audit.

When auditors come asking what were these ₹5L UPI credits?, you’ll have one-click answers.

Set up alerts for:

• Daily total UPI usage
• Per-VPA inflow caps
• High-value payments
• Failure spikes
• Pending settlements
• Split payments
• PSP latency

That gives finance a live radar on UPI flow before caps or timeouts start breaking checkouts.

Ah, the classic UPI retry storm problem one FD payment lags, and suddenly your system hammers the PSP 50 times like it owes you rent.

If your reconciliation engine is involved in posting or retrying UPI payments for term deposits, you’ve got to rate-limit and back off intelligently when response times get ugly.

Here’s how to handle it cleanly:

• Watch latency in real time

Your reconciliation service should be monitoring average UPI API response times from PSPs or payment gateways.

Once it crosses a threshold (say, >2 seconds for collect requests or >5 seconds for status checks), mark the PSP as degraded.

You can track this using a rolling 5-minute window:

if avg_response_time > 2s for last 20 calls:

PSP_status = DEGRADED

• Switch to exponential backoff

Instead of retrying instantly, back off exponentially when in degraded mode.

Never let reconciliation keep hammering NPCI endpoints or gateway APIs — you’ll just make the latency worse.

• Use a per-category throttle for FDs

Term deposit openings are high-value and not time-sensitive like bill payments.

Throttle them harder e.g. 2–3 retries max over 15 minutes.

Meanwhile, keep low-value UPI collections (like ₹100 bills) on a faster retry policy.

That means your logic should check something like:

if txn.category == TERM_DEPOSIT:

set_retry_policy(slow)

else:

set_retry_policy(normal)

• Pause retries globally if latency spikes across PSPs

If all your PSPs (Razorpay, Cashfree, PayU, etc.) are lagging at once, it’s probably an NPCI or bank switch issue.

In that case, trigger a global cooldown stop retries for 5–10 minutes and show users a soft message like:

UPI networks are slower right now. Your FD payment will be retried automatically once things stabilize.

• Alert finance + ops teams

When throttling kicks in, send a Slack/email alert to finance or ops:

• UPI retries throttled for FD transactions
• Include metrics like current latency, pending transaction count, and next retry time.

That keeps everyone informed without manual digging.

• Resume normal retries automatically

When your average response time drops back below the threshold (say, <1.5s for 3 consecutive minutes),

mark the PSP as healthy again and restore normal retry intervals.

So after the 2025 UPI update, education fee payments and term deposits were moved into the high-value, permitted category — meaning NPCI and banks can now allow higher per-transaction limits (₹2L–₹5L) if the payment is tagged correctly.

If your billing system supports UPI for schools or universities, you can show real-time messages when the customer’s bank supports those higher limits.

Here’s how to wire that up:

• Detect the transaction category early

When the invoice or payment link is created, tag it as:

upi_category: EDUCATION_FEES

That category code is how NPCI and PSPs decide whether the higher limit applies.

If the backend already knows the payment is education fees, pass that in the UPI intent or collect payload.

• Query PSP / Bank capability in real time

Before showing the payment screen, ping your PSP or UPI SDK (like Razorpay, Cashfree, PayU, etc.) for the payer’s bank + PSP profile.

They usually return metadata like:

{

bank: HDFC Bank,

upi_limit: 500000,

category_supported: [EDUCATION_FEES, TERM_DEPOSIT]

}

If the category and limit match your transaction, boom — eligible.

• Surface the message on the payment screen

When you detect eligibility, show a non-intrusive banner or toast right under the UPI option:

Good news!

Payments for education fees are eligible for higher UPI limits (up to ₹5,00,000) with your bank.

If the user isn’t eligible:

Your bank’s UPI limit is ₹1,00,000 per transaction. Try NetBanking or split your payment.

No one wants to hit Pay and watch it fail after 5 seconds.

• Cache the limit per bank / PSP

You don’t need to query NPCI every time.

Cache UPI limits per bank + category for a few hours.

• Show fallback recommendations

If the user’s limit is low, suggest next best options right on-screen:

You’ve hit your ₹1L UPI cap. Try splitting into smaller UPI transfers or use NetBanking.

Keeps checkout smooth without confusion.

• Optional: Add a soft eligibility check before QR render

If you’re using intent flow or dynamic QR, validate eligibility before generating the QR.

That saves unnecessary QR refreshes or collect failures.

If your payment gateway is handling big education fee payments, you’ve probably run into UPI’s per-transaction cap issue. Most banks still limit UPI transfers to ₹1 lakh (sometimes even less), so if a parent tries to pay ₹1.5 or ₹2 lakh in one go, the transaction just fails. The simplest fix is to make your integration smart enough to auto-split the payment before it ever hits that limit.

Prior to starting a collect request, make sure you are aware of the current UPI transaction cap. Set off a split workflow that splits the total into smaller amounts, such as ₹1 lakh and ₹50,000 for a ₹1.5 lakh cost, if the amount exceeds that maximum. To ensure that every part of the transaction can be tracked while still being connected to a single source record, store these as linked sub-payments under a single parent invoice.

You can send these payments either sequentially (one after another) or in parallel. Sequential is usually safer, less chance of partial or double payments, while parallel can save time if your PSP supports it. Either way, make sure your checkout page clearly tells users what’s happening. Something like, your fee exceeds the ₹1L UPI limit. It will be processed in 2 secure payments. That kind of messaging prevents confusion and reduces support calls.

Once both UPI payments succeed, mark the main invoice as fully paid. If one leg fails, tag it as Partially Paid and only retry that portion. The reconciliation logic should automatically match all child payments using their UPI reference IDs, so finance can see everything tied to one invoice in their reports.

Refunds should follow the same logic, break them down into parts that mirror the original split amounts, or the PSP will reject them.

Finally, set up a daily finance alert that shows how many split UPI payments were processed and their total value. It keeps teams aware of how often you’re hitting caps and where limits might tighten.

Update your billing engine so it:

• Accepts ₹5L single UPI settlements for education category.
• Maps them to a distinct Education UPI ledger.
• Handles delayed settlement posting.
• Supports higher refund ceilings or auto-split refunds.
• Generates daily reconciliation reports by category.

That’s all it takes to keep your education-fee UPI receipts compliant, traceable, and clean in your books, without tripping your finance or audit workflows.

When UPI caps are hit, your platform should:

• Detect the cap automatically.
• Suggest NetBanking, Card, or Split UPI.
• Retry intelligently with smaller amounts.
• Offer EMI or payment links for bigger fees.
• Explain the reason clearly in-app.

That combo keeps your checkout smooth and prevents frustrated parents from calling the finance desk because UPI didn’t work again.

Once UPI caps are reached during a term deposit opening, your mobile app should:

• Detect and explain the limit breach clearly.
• Offer smart fallbacks: Net Banking, Debit Card, eNACH, or Virtual Account transfer.
• Auto-route users based on transaction amount and urgency.
• Keep UX smooth with contextual messages and one-tap redirection.