Integrating Payment Gateways with Hosting

Bro, just integrate Stripe. It’s one API call.” Famous last words before you end up debugging webhooks, idempotency, and double charges at 2 AM. And that’s how I lost 2 weeks of my life debugging what looked like a 10-line API call. Let me explain what really happens when you implement payments 👇 Step 1: The Illusion - “Frontend Integration” You add a Checkout button, call Razorpay/Stripe API, user pays, frontend says “Success.” Money deducted. Job done? Nope. Because that “success” is just the browser’s response. If the user closes the tab before redirection — the payment still happens, but your app never knows. Lesson: Frontend != Source of Truth Step 2: The Payment Object You can’t just depend on the gateway. Every payment needs to exist in your own database first. When the user starts checkout, create a Payment object in your DB: Payment {   id: uuid,   order_id: xyz,   status: "INITIATED",   amount: 499,   gateway_payment_id: null,   user_id: abc } This lets you track the full lifecycle - even if webhooks arrive late or twice. Step 3: Webhooks - The Real Source of Truth When the gateway sends a webhook (e.g. payment_success), that’s when you verify, update your DB, and unlock what the user paid for. But gateways retry webhooks (sometimes multiple times). So you need idempotency — so the same event doesn’t trigger multiple unlocks. A simple rule: Use the gateway_payment_id as a unique key. if not exists(gateway_payment_id):     mark_payment_success()     unlock_user_access() else:     ignore_duplicate_event() Now your backend behaves deterministically - even under retries or duplicates. Step 4: Ensuring User Access After Payment This part hurts the most. Users expect instant access after paying. But your webhook might arrive a few seconds later. So here’s how to handle it right 👇 On frontend, optimistically show “Payment successful, verifying…” Backend gives access only when webhook confirms it. If webhook is delayed, show a loader or poll for status every few seconds. That 5-second delay saves you from massive refund chaos later. Step 5: Reconciliation & The Real-World Mess At month-end your finance team will ask: “We got ₹98,120 in the bank, but system shows ₹97,950. Why?” Now you’ll compare your DB -> gateway reports -> settlement bank entries (T+2 delays). Only then will you realize… Payment integration isn’t a feature - it’s an event-driven distributed system that happens to move money. 💡 The Moral "Just integrate payments" sounds simple - until you realize it’s about: - Async systems - Idempotency - Race conditions - Data consistency And human impatience 😅 It’s the perfect real-world test of whether your system design actually holds up. Next time someone says “It’s just an API call”… send them this post.

🚀 #CreationalPattern Series – Part 3: Abstract Factory 🔹 Abstract Factory – Integrate Multiple Payment Gateways Without Hardcoding Providers Building a scalable e-commerce platform that supports multiple payment gateways like Stripe, PayPal, or Razorpay Want to decouple business logic from provider-specific APIs? The Abstract Factory Pattern is your go-to solution. 🎯 Intent: Define an interface for creating families of related objects (e.g., payment + refund services) without binding to specific classes. 🎨 Real-World Analogy: Each provider offers its own SDK for payment and refunds. You need a unified way to plug in the right gateway based on business needs without changing internal logic. 🛠️ Use a factory to provide related services — all from the same “family” (e.g., Stripe or PayPal). 🧱 C# Implementation: interface IPaymentService { void Pay(decimal amount); } interface IRefundService { void Refund(string txnId); } class StripePayment : IPaymentService { public void Pay(decimal a) => Console.WriteLine($"Paid {a} via Stripe"); } class StripeRefund : IRefundService { public void Refund(string id) => Console.WriteLine($"Refunded {id} via Stripe"); } class PayPalPayment : IPaymentService { public void Pay(decimal a) => Console.WriteLine($"Paid {a} via PayPal"); } class PayPalRefund : IRefundService { public void Refund(string id) => Console.WriteLine($"Refunded {id} via PayPal"); } interface IPaymentGatewayFactory { IPaymentService CreatePaymentService(); IRefundService CreateRefundService(); } class StripeFactory : IPaymentGatewayFactory { public IPaymentService CreatePaymentService() => new StripePayment(); public IRefundService CreateRefundService() => new StripeRefund(); } class PayPalFactory : IPaymentGatewayFactory { public IPaymentService CreatePaymentService() => new PayPalPayment(); public IRefundService CreateRefundService() => new PayPalRefund(); } class PaymentProcessor { private readonly IPaymentService _payment; private readonly IRefundService _refund; public PaymentProcessor(IPaymentGatewayFactory factory) { _payment = factory.CreatePaymentService(); _refund = factory.CreateRefundService(); } public void ProcessPayment(decimal amt) => _payment.Pay(amt); public void ProcessRefund(string id) => _refund.Refund(id); } 🧪 Usage: var factory = new StripeFactory(); var processor = new PaymentProcessor(factory); processor.ProcessPayment(1200); // Paid 1200 via Stripe processor.ProcessRefund("TXN123"); // Refunded TXN123 via Stripe ✅ Benefits: Decouples app logic from SDKs Supports Open/Closed Principle Ensures consistency between related components Easy to test via mock factories Ideal for SaaS, fintech, multi-tenant platforms 🧠 When to Use: Need multiple SDK integrations Require consistent behavior across services Want to switch providers at runtime 🔜 Next in the Series: Builder Pattern – construct complex objects step-by-step.

Real-Time Payment Gateway Sync Goal: When a payment is initiated from Salesforce, we need to: 1. Trigger a callout to the gateway (Stripe-like) 2. Handle success/failure callbacks 3. Update the related Opportunity and Payment Status instantly Here’s the approach: 1. Named Credentials + Custom Metadata We used Named Credentials for secure authentication and stored dynamic endpoint configs in Custom Metadata for multi-environment support. 2. Apex Callouts with Continuations To handle the delay in response from the gateway, we used @future methods for async callouts, and in some cases, Continuations for long-running requests. 3. Platform Events for Callback Handling The external system published to a Platform Event (via a middleware layer) once payment was completed. A trigger on the event updated the relevant Opportunity and Payment object in real-time. 4. Retry & Logging Mechanism Built a retry queue with exponential backoff for failed callouts + error logging for traceability. Challenges: • Managing auth token refresh cycles • Ensuring idempotency to prevent duplicate updates • Handling partial failures gracefully Impact: • Real-time visibility into payment status • Clean decoupling between systems • Scalable architecture ready for future enhancements Salesforce integrations can get complex fast—but with the right tools and patterns, you can build rock-solid, real-time systems. #Salesforce #Integration #PlatformEvents #NamedCredentials #Middleware #Apex #PaymentGateway #RealTime #SalesforceDeveloper #BestPractices