What accessibility checks ensure Adyen features meet WCAG 2.2 AA standards?

You must work with your bank for merchant verification and interface with a payment gateway that supports the most recent UPI APIs in order to demonstrate real-time eligibility for larger UPI limits.  The higher limit choice can then be dynamically displayed at your e-commerce checkout for purchases in qualified categories like travel, investments, or insurance.

When QA tests UPI refunds and reversals under the new high-limit rules, they should focus on four main buckets: correctness, compliance, concurrency, and reconciliation.
Core refund/reversal validations

• Full refund success – Initiate a refund equal to the original transaction amount (even if >₹2L) and verify it posts successfully for verified merchants.
• Partial refund success – Validate that multiple partial refunds against the same UPI Ref ID are allowed and reconcile correctly.
• Refund cap breach – Try refunding more than the original amount or beyond daily refund limits to ensure proper error (LIMIT_EXCEEDED or PSP-defined).
• Reversal after auto-refund – Simulate double credit scenarios where your system mistakenly retries a refund and confirm idempotency prevents duplicates.

Timing and window edge cases

• Refund outside allowed window – Test refunds initiated after NPCI’s refund cut-off (typically T+1/T+2) to confirm they’re rejected gracefully.
• High-value reversal delay – Validate how long large reversals take to reflect in settlement files; your ERP should still mark them “pending reversal” until confirmation.
• Refund retry under PSP timeout – Simulate PSP latency during peak hours to verify your retry/backoff logic (especially for ₹5L+ refunds).

Concurrency and split-payment scenarios

• Split invoice refund – If the original payment was split into multiple UPI legs, ensure refund logic correctly targets each UPI Ref ID and matches proportionally.
• Concurrent refunds – Two refund requests fired at once for the same transaction should trigger one success and one duplicate rejection.
• Daily limit overlap – Simulate when a merchant is close to their ₹10L daily limit and issues a refund that would push them past it — should fail or queue per PSP policy.

Reconciliation and ledger checks

• Refund reflected in PSP file – Make sure every refund entry appears in NPCI or PSP settlement files and matches your ledger.
• Customer advance vs. revenue correction – Test accounting mappings: refund on advance should reverse liability, refund on sale should reverse revenue.
• Mismatch alerting – Simulate a failed refund that PSP reports as success (or vice versa) and ensure your reconciliation job flags the mismatch automatically.

A travel booking engine should adapt its checkout to increased UPI limits by integrating a multi-limit UPI option, providing seamless multi-payment choices for larger transactions, and enhancing user experience through features like split payments and a multi-stage checkout process. By allowing users to pay with different UPI accounts, split a single booking across multiple payments, or combine UPI with other methods like credit cards, the platform can cater to a higher spending capacity and offer greater flexibility, thereby improving conversion rates and user satisfaction.

Gather the constraints up front

• Source per-transaction and per-day caps from your PSP / acquirer (or from a config table you keep updated per NPCI rules + merchant verification status + MCC).
• Also fetch merchant’s remaining daily allowance (from PSP API or your local ledger of successful UPI receipts).
• Enforce any PSP-specific rules (min txn amount, max legs allowed, supported UPI modes).

Decide UX / business rules

• Decide whether splitting is automatic (ERP will try to split) or opt-in (customer chooses split/pay later).
• Prefer showing the user: total, per-leg amounts, number of legs, and which payment methods are alternatives (card/netbanking) before attempting collects.
• For B2B invoices, ask if partial payments are allowed; if not, block UPI and suggest alternate flows.

Algorithm to compute safe splits (basic, robust)

• Let Tcap = per-transaction cap, Dcap = daily cap, R = remaining daily allowance for merchant, Amount = invoice total.
• Effective single-leg ceiling Ceil = min(Tcap, R).
• If Amount <= Ceil → single collect.
• Else compute legs greedily: take as many Ceil legs as needed, last leg = remainder. If last leg < PSP minimum amount, adjust by balancing (e.g., distribute across legs to keep all ≥ min).
• Also check maximum number of legs allowed; if exceeded, fallback to alternate payment or require manual handling.

Orchestration & atomicity (critical)

• •    Create a single InvoicePaymentPlan record linked to invoice with legs array (leg_id, amount, status, psp_txn_id, upi_ref).
• For each leg call PSP pre-check API (if available) to confirm remaining daily limit and allowed amount. If no pre-check, proceed but be prepared to handle failures.
• Execute collects sequentially or in controlled parallelism: prefer sequential (leg1 → leg2 → …) because daily allowances and race conditions can cause mid-flow failures.
• Implement reversible flows via PSP APIs (reversals/refunds) and mark everything in your ledger before returning success to caller.

Idempotency & retries

• Use idempotency keys per leg (invoiceId:legIndex:attemptId) so retries don’t double-charge.
• Backoff / retry on transient errors; on definitive errors (LIMIT_EXCEEDED, DAILY_LIMIT_REACHED) stop retries and surface next steps to user.

Reconciliation & GST / e-invoice mapping

• Store psp_txn_id and upi_ref for every leg and include them in your GST e-invoice Payment array (one entry per leg).
• Ensure your settlement batch logic aggregates legs correctly: settlement files from PSP may show separate credits — map them to invoice via psp_txn_id.
• If auto-reversal happens, generate credit note / adjusted invoice and record reversal UPI ref.

Notifications & UX

• Notify user/customer at three touchpoints: (a) when split is created, (b) as each leg succeeds/fails, (c) final invoice status.
• Provide clear error messages: UPI daily cap reached — try smaller amount, card, or complete tomorrow.

Auditability & monitoring

• Log every API request/response and store raw PSP error codes (to tune thresholds).
• Add alerts for patterns: many LIMIT_EXCEEDED responses, high rate of compensations, reconciliation mismatches.
• Track KPIs: split success rate, average legs per invoice, compensation rate, reconciliation delta, time-to-full-payment.

Edge cases & testing

• Simulate concurrent spends that consume merchant’s remaining allowance mid-flow (race conditions). Build tests that:
• Force second-leg DAILY_LIMIT_REACHED and ensure compensation works.
• Simulate webhook/callback lost and verify polling reconciles status.
• Verify idempotency under duplicate webhooks or client retries.
• Test refunds across split legs: full refund should create refunds across legs proportionally or in defined order (document policy).

Security, compliance

• Don’t store PAN/card data — store only PSP tokens and UPI refs. Ensure logs containing sensitive identifiers are redacted.
• Maintain audit trail for NPCI/RBI compliance — per-txn UPI refs, timestamps, merchant verification status, and settlement files.

Implementation sketch (pseudo-code)
def split_invoice(invoice)

Rollout & Ops

• Roll out with a canary: only for verified merchants and a small % of invoices.
• Feature flag the auto-split behavior so you can disable instantly.
• Provide support playbooks for agents to handle partial payments and reconciliation questions.

To restrict external sharing in Razorpay Subscriptions while still enabling collaboration, you should use Razorpay's native team management features rather than sharing information or links externally. This involves inviting specific users, assigning them roles with limited permissions, and using the secure subscription link feature for customer-facing interactions.