
The Divine Comedy of the Everyday User
We were promised a digital paradise....
Read more The Divine Comedy of the Everyday User

In 1994, a guy named Phil Brandenberger made the first online purchase in history: he bought a Sting CD for 12.48 dollars over a secure SSL connection. From that moment, the era of online payments began.
Thirty years later, things have become… more complicated.
Today, the term “e-commerce platform” can mean almost anything: from an out-of-the-box SaaS website builder where payments are plugged in within a few clicks, to a multi-layered custom architecture with dozens of API connections and microservices.
Shopify or BigCommerce let you launch a basic store in a few days. Stripe, PayPal, Apple Pay are built into the box. But in custom headless solutions everything is different: there is not even an interface, only an API. Everything from order logic to payments is assembled manually, step by step. Each module requires integration, testing, and coordination, and the most vulnerable among them often turns out to be the payment gateway.
Modern e-commerce solutions are a single organism. If one part fails, there will be no order, no payment, and no customer. And as in any organism, inter-system connections are more important than individual functions.
The point is not how many features a platform has, but whether it can integrate at all. If the CRM does not know about the payment, the customer does not exist. If the ERP did not receive the status, there will be no shipment. If checkout is not synchronized, conversion drops, and with it the entire business model.
In this article, we will break down what types of e-commerce solutions exist and how they differ, how to choose a platform for specific business tasks, how the payment system is woven into the architecture, and what requirements the payment infrastructure imposes. And how to integrate all this so that you do not have to redo everything six months later.
Of course, the e-commerce solutions market does not look like a table with four columns, but to understand how the integration of a payment gateway into e-commerce works, you need to clearly distinguish the logic of these platforms. Because it is this logic that determines both the capabilities and the limitations.
The fastest way to go online is to rent a ready-made platform. Shopify, BigCommerce, and Wix are SaaS solutions with pre-installed functionality: templates, marketplaces, basic analytics, payment systems. Integrations are connected through an app marketplace; Stripe, Apple Pay, and PayPal are available in a few clicks.
This is ideal for small businesses: a quick launch with no development. But limitations come with growth: customization becomes more difficult, access to the code is minimal, and dependence on third-party services is high. Even critical nodes such as the payment process often run through intermediary modules.
WooCommerce is a popular option for those already on WordPress. Magento is more powerful and complex with broader customization capabilities. The main advantage is full control over the logic: you can change the sequence of actions, add fields, and implement your own payment processing.
But flexibility comes with responsibility: stability and security depend on the implementation. A bad plugin or outdated module can bring the system down. The more custom features you add, the more risks you create. Here, you cannot do without technical control (tests, audits, maintenance).
This includes everything built from scratch for specific business needs: on Laravel, Node.js, Django, or entirely from microservices. Typically, these are used for products with complex logic: marketplaces, multi-regional solutions, systems with roles, dynamic pricing, and integration with inventory, logistics, and CRM.
Integration of the payment gateway is always developed manually here via APIs, SDKs, or custom services. This is an advantage because it gives full control over UX, validation, payment logic, callbacks, and analytics. But it is also a drawback because each integration takes time, requires technical support, and demands a deep understanding of the payment stack.
For such solutions, it is important to choose the payment system even before development starts. Not all providers are equally flexible, and not all allow you to implement the desired UX (for example, tokenization, subscriptions, partial payments, or split payments).
Headless is an approach where the frontend and backend are separated. The interface can be the web, a mobile app, or even a terminal, while the logic lives on a separate backend. Magento, Shopify, Contentful, and Strapi can all be parts of such a system.
The main advantage is full freedom. You can build a custom UX, roll out changes without reworking the core, and create an omnichannel architecture. But the price matches: integrating any module, including payments, becomes a separate backend task. Headless works best where scalability and flexibility are needed. But without a strong development team and solid technical management, this approach turns into an endless integration battle.
So if you boil it all down to a single scale, the difference between these four approaches lies in the depth of integration. In some cases, activating a ready-made function is enough; in others, everything has to be built from scratch. And this is what determines the cost level, technical complexity, and post-launch risks.
It is important to understand that the payment gateway for e-commerce is only the tip of the iceberg. If everything else in the system is broken or fragmented, even the best integration will not work. Checkout may fail due to an event-tracking error, the CRM may not see the order because of an incorrect API response, and the ERP may hang when updating the status. And if the order does not move further in the chain for any reason, the customer will see only one thing: “payment failed”.
Next, we will go through the key modules that directly or indirectly affect the stability of the payment process. If at least one of them is unstable, problems are only a matter of time.
Everything starts with the catalog, but the real question is data structure, not the number of items. If products do not have unique IDs, variations, currencies, attributes, and SKUs, the integration with the payment system will start breaking already at the cart-creation stage. Moreover, many payment solutions require passing information about each item in the order, and without the right data model, this becomes a problem that cannot be solved without rebuilding the entire catalog.
Checkout is the point where conversion either happens or does not. The main obstacle here is when UX at this stage is designed like a maze. The most common mistakes are fixed delivery methods, manual validation, unpredictable errors when changing the address or payment method, and a gap between frontend and backend. All these factors directly affect payments. And even if the money has been debited, the order can still be lost in the system.
The ideal payment-gateway integration into the shopping cart should be implemented in 2–3 steps with live validation, preservation of entered data, and adaptability to different payment types. And most importantly, there should be the ability to integrate an external payment process without risking breaking everything.
And each of these points is a separate integration task. Especially if you don’t have Stripe or PayPal, but something custom or local.
After a successful payment, the customer expects the product to be in stock. But if both processes (payments and inventory) operate separately, with delays or cached balances, transaction rollbacks or returns will become a regular scenario.
An ideal system reserves the product at the moment the “Pay” button is clicked and deducts it after confirmation. For this, synchronization is needed: payment logic must be linked to inventory accounting, and in real time.
In 2026, over 70% of online orders come from mobile devices. Yet many systems still do not test the payment form in the mobile version. As a result, fields shift, the confirmation button gets covered by the keyboard, Apple Pay does not work, or Touch ID fails to confirm the payment.
Every such failure is a lost transaction. In more complex scenarios like subscriptions or installment payments, it also means dozens of support requests.
Mobile adaptation is not an extra plus but a basic requirement for any payment system integration. It must be checked not only from a design perspective. It is crucial whether the mobile scenario is supported at the SDK level, whether payment data encryption works correctly, and whether the embedded browser blocks payment completion.
This is the last module that is usually mentioned after launch, but it is a mistake. Analytics allows you to see how many payments were not completed, at what stage users abandon the process, how many times they clicked “pay” but did not reach confirmation.
Without real-time connection to the payment system, you will not know what went wrong until the customer complains. Without clear reports, you will not understand which payment methods work effectively and which do not. Without event logging, you will lack arguments in case of disputes or bank-mandated refunds.
Each of these functions directly affects how the integration is implemented. A poorly designed system forces patching weak spots and using temporary fixes. In contrast, a quality e-commerce architecture enables fast payments without losses at every step.
There is no universal platform: some work better with prepayments, others with installments. Somewhere inventory balances update in real time, elsewhere once a day. Multi-currency, subscriptions, returns, reserves—all this is implemented differently. If the system does not handle these processes out of the box, payment gateway integration turns into a problematic custom solution with manual synchronization.
To avoid this, the platform must match your business model, internal processes, and pace of changes.
If the main goal is to quickly enter the market and test the model, SaaS platforms (Shopify, BigCommerce, Wix) are the most practical choice. Setup takes a few days, payments connect without developers, and main scenarios work right away. Stripe, PayPal, Apple Pay are available immediately. Less manual work and fewer points of failure.
This is an ideal environment for launch and first sales. But do not harbor illusions: no custom logic here. Reporting is basic only, and complex rules or non-standard processes require additional modules, paid integrations, or workarounds.
Therefore, if growth is planned, think ahead about migrating to a more flexible architecture. Otherwise, what enabled a quick start will become what hinders development.
At this stage, tasks emerge that cannot be solved with off-the-shelf solutions: integration with accounting systems, CRM, multi-currency, multiple warehouses, complex product structures. This is when transitioning to open-source or custom development becomes necessary.
WooCommerce suits as a temporary option: basic flexibility without full code immersion. Magento or custom architecture is for those who understand they are taking on maintenance responsibility. Without a technical team, such a system will not last long: something will crash, something will not update.
Payment system integration here is a full-fledged technical task: API connection, data validation, secure transmission, scenario testing. But there are more capabilities too: working with local gateways, partial payments, splitting between multiple recipients, combined payment models.
In the corporate segment, e-commerce is just one subsystem of a large infrastructure. It must work synchronously with ERP, SSO, tax modules, analytics, and internal services within each region.
The key requirement is full controllability of the process. No API change or legal norm should disrupt transaction processing. Hence, the typical approach is headless or custom architecture with separation into regional frontends and microservices for specific business processes. Everything operates with defined SLAs, backup communication channels, and failure protocols.
Payment system integration in this model is a critical element. An error here means stopping revenue. That is why custom adapters or an intermediate technical layer between the gateway and backend are often created for stability.
In such projects, it is important to build a payment integration that does not need to be reworked every three months. Because every rework means lost profits and dissatisfied customers.
There is no point in accepting online payments if the order then gets lost somewhere between CRM, inventory, and email campaigns. In 2026, integration is the logical link between all key modules of the e-commerce ecosystem, which must synchronously respond to the fact of payment.
Here are four integration points without which even the most beautiful checkout will quickly turn into a source of errors with endless support requests.
After payment, the order should not stay only on the e-commerce platform. It must automatically go to the CRM, be linked to a specific customer, and include status, receipt, payment method, and full transaction history.
Without this, managers cannot see who bought what, when, and for how much; they cannot segment the base, launch personalized campaigns, or maintain loyalty.
Especially important: the payment event must not only create a contact in the CRM but also update its status in real time (for example, confirmed, canceled, pending confirmation).
ERP systems manage inventory, logistics, procurement, and accounting. If the payment system is not integrated with ERP, a bunch of errors arise: finance does not see the payment, inventory does not see the order, or analytics shows incorrect revenue.
In a quality integration, the payment event automatically updates the status in ERP: a transaction appears, balances are deducted, reporting is updated, and an accounting document is created. All without manual intervention.
Another key aspect: compatibility in currencies and tax models. Many e-commerce companies operate in multiple jurisdictions, and ERP must correctly process this data depending on the country, customer type, and payment type.
The worst type of automation is one that knows nothing about the customer. The system may perfectly send emails, push notifications, or SMS, but if it does not see that the payment went through or the order was canceled, the budget is wasted.
Real control starts with events. Was the payment confirmed or not? Did they abandon the cart before or after entering card details? Was there an error or a retry?
These small technical details are triggers without which normal retargeting is impossible. Because they determine what the customer gets: a relevant reminder or another annoying spam.
This is the most painful spot. Often the order is successfully paid but does not reach the delivery system. Or the status was changed manually, and now it is unclear whether to ship the product or not.
Payment gateway integration with the logistics module (or separate fulfillment services) should confirm the order only after payment, automatically create shipments, update tracking status after payment status changes, and allow returns through the same channel.
Without this, chaos ensues: duplicates, lost shipments, SLA violations, and returns via hotline.
All these integrations do not have to be built simultaneously, but if none of them work, it is not an e-commerce system but a set of isolated ones. The payment event must become the trigger for all subsequent processes.
No one wants to lose a customer at the payment moment, especially after investing tens of thousands in e-commerce development. But this happens when the budget for payment system integration is treated as an afterthought.
In reality, this part can turn out to be the most expensive. Because it involves everyone’s interests: designers draw one thing, backend sees another, lawyers demand a third, and support then catches the fallout. Add security, UX, analytics, testing—and you have a perfect cocktail for bugs, refunds, and complaints.
So what really goes into the budget for online payment gateway integration?
Technical Implementation
SDK integration, API work, scenario testing (successful payment, decline, timeout, refund, partial payment), callback handling, rollback logic, multi-currency. Costs can range from $2,000 to $15,000 depending on customization level and number of scenarios.
UX Integration
UX integration covers not just the payment form’s appearance but how it behaves: is it clear what to do at each step, do unexplained errors occur, does the keyboard cover the button on mobile, does the form hang on load. Every such detail is a point where the user might change their mind. If the experience is inconvenient or slow, conversion losses can reach 30-50%.
Certification and Security
PCI DSS, 3D Secure, data encryption, payment processing policies, internal audit, tokenization, GDPR compliance, payment event logging. Often requires separate audits or proxy gateways if your own system is not certified.
Technical Support
Gateways crash, APIs change, statuses do not always arrive correctly. Someone must monitor, log, fix errors, and respond to customer queries.
Payment Provider Commissions
Stripe, PayPal, WayForPay, Fondy, LiqPay, Adyen—all take a percentage. Sometimes per transaction, sometimes on withdrawals. Additionally: chargeback holds, setup costs. Commissions range from 1.5% to 3.5% per transaction, which adds up significantly on annual volume.
Synchronization Modules
Payment status must appear in ERP, update CRM, and pull into analytics. If the system consists of modules, each integration is separate and requires development.
It is important to check what happens in case of failure. Because if an order gets stuck between payment and shipment, losses are inevitable.
Potential Losses
Most e-commerce problems start because typical errors were not anticipated. For example, 5% of customers cannot pass 3D Secure from mobile and stop one step before payment. That is 5% lost revenue they might not even notice.
Bad news: most failures are discovered post-launch, when money is frozen, orders do not arrive, and the team spends hours finding what broke.
Good news: if the integration is designed correctly, most of these problems simply do not arise.
In many e-commerce projects, payments are connected last, and that is when problems start. It seems minor, but as soon as it comes to 3D Secure, refunds, timeouts—the system starts crumbling: money is debited, but the order is not created. Meanwhile, support does not see at what stage something went wrong.
Payment integration is a separate technical process. If it is not designed as a system with clear stages, responsibility zones, and a failure plan, you will have to patch it post-launch in emergency mode.
Provider choice affects everything: supported scenarios (one-time payment, subscription, split payments), time to market, and system stability.
Usually, the choice takes 3–5 days. If there is no clear understanding of requirements, it can take up to 2–3 weeks for verification, negotiations, and bureaucracy.
Before integration, key points must be defined: Will payment be inside the site, on a separate page, or via iframe? Who validates data—frontend or backend? Where is the transaction status stored? What happens if the user closes the tab?
These details determine the entire system’s stability. For example, if product reservation is not synchronized with payment, you can lose both the product and the money. If there is no error-handling logic, the user will simply leave.
Planning usually takes 2–5 days. Skimping on time here costs dearly after launch.
This is when code starts working with real money.
The team connects the SDK or API, implements payment logic (success, decline, refund), and sets up failure scenarios. Special attention goes to callbacks, as they confirm the payment and trigger updates in CRM, ERP, inventory, and cart. If this chain breaks, the order hangs.
Average time: SaaS—1–3 days, open-source—3–7 days, custom—from 2 weeks and up.
This stage acts as a safeguard against revenue loss. The system must pass dozens of scenarios: successful payment, cancellation, hang-up, timeout, 3D Secure issues, mobile adaptability. It is crucial to check the full cycle: from “Pay” click to ERP status and customer email.
This usually takes 2–5 days, and it decides whether the system will run stably.
Post-launch is when the real fun begins: do payments reach completion, do statuses update correctly, is support ticket volume rising? Only logging reveals where something broke if a customer complains about debited money but no order.
In summary, the entire integration process typically takes 1–4 weeks depending on architecture type, chosen gateway, and backend readiness.
Payment system integration is one of the most critical points for e-commerce in 2026. It affects UX, finance, analytics, security, and reputation. Plus dozens of small scenarios that are easy to miss.
At IWIS, we help businesses avoid pitfalls and build an architectural solution that matches business logic, withstands load, scales with the project, and integrates with ERP, CRM, and marketing.

We were promised a digital paradise....
Read more The Divine Comedy of the Everyday User
On World Usability Day and during...
Read more UX Design Tips from AliExpress