~ Mohan Sankaran.
From point solutions to platform thinking
Most merchant apps began life as helpful tools: take a payment, send an invoice, track a sale. Useful, but narrow. As merchants grew, they stitched together a patchwork of products-checkout here, invoicing there, shipping somewhere else-each with its own login, data model, and support channel. The experience felt like juggling. The shift now underway is simple to describe and hard to build: one platform layer where payments, risk, and analytics live side by side, sharing the same identity, data, and decisions.
From features to primitives
Platforms endure because they’re built on primitives, not one-off screens. For merchants, those primitives are payment intents, customers, items, balances, disputes, and payouts. When these are modeled cleanly, everything else-recurring billing, subscriptions, BNPL, marketplace splits-becomes composition, not custom work. Risk isn’t bolted on; it’s a property of each primitive. Analytics isn’t a separate dashboard; it’s a lens on the same objects. The result is less glue code, fewer surprises, and an interface that grows with the business instead of constraining it.
From dashboards to decisions
A merchant doesn’t wake up wanting charts; they want answers. Did revenue grow? Which items drive margin? Which refunds are trending risky? The platform era turns telemetry into decision loops. Signals from payment flows, catalog changes, and customer behavior stream into a common model. Real-time risk scores can adapt checkout friction on the fly. Inventory can auto-reorder. Marketing can target the segment that’s actually converting, not the one that merely clicks. The merchant stops switching tabs and starts steering from a single pane of truth.
From bolt-on risk to embedded trust
Fraud used to be a separate team and a separate tool. In a platform, trust is native. Every action-login, cart update, payment, payout-emits signals that feed a shared risk engine. Device posture, geovelocity, chargeback histories, and behavioral patterns converge into a live confidence score. Low-risk journeys flow without friction; anomalous ones get step-up verification or slower settlement. Because payments and risk share the same objects and events, defenses are immediate, specific, and largely invisible to good users.
From APIs to a graph of commerce
Microservices liberated teams, but they scattered data. A platform re-aggregates that view without re-centralizing code. A schema-first API-often a graph-presents one contract to every client: mobile app, POS, back office, partner integrations. The merchant experience becomes query-driven: get exactly the fields a screen needs, subscribe to only the changes that matter, and evolve safely through additive schema changes. Behind the front door, services publish events and react to them; in front, the surface stays consistent, fast, and battery-friendly.
From releases to rollouts
Merchants can’t plan their week around your deploy. Platform cadence shifts from “big releases” to controlled rollouts: feature flags, canaries, config-driven behavior, and instant rollback paths. Risk thresholds update without binaries. A/B tests run on the platform layer, not in ad hoc code. When something fails-and it will-the impact is contained, the fix is targeted, and the learning feeds back into guardrails. Reliability stops being heroics and becomes a habit.
From data exhaust to a durable memory
Data scattered across tools is exhaust; data woven into a merchant memory is leverage. The platform’s event backbone-clean schemas, correlation IDs, and lineage-lets you replay the business: how orders turned into shipments turned into payouts, where customers came from, which campaigns paid off. That same memory trains models responsibly: anonymized where needed, aggregated by design, governed with retention and access controls that auditors can follow and engineers can trust.
From walled gardens to extensibility
No single roadmap fits every merchant. The platform’s superpower is extension: an SDK, webhooks, and an app marketplace that let partners add niche capabilities without forking the core. A boutique needs appointment deposits; a restaurant needs table-level routing; a marketplace needs split settlements. Extensions plug into the same primitives and events, inherit the same risk posture, and surface in the same UI shell. The platform grows because others can safely build on it.
From app to operating system
When payments, risk, and analytics converge, the product stops feeling like an app and starts behaving like a merchant OS. It authenticates, observes, decides, and adapts. It learns the business while protecting it. It makes the complex simple without hiding the details from those who need them. Most importantly, it turns trust into a system property-earned through design, measured in outcomes, and renewed every time a tap becomes a sale.
Ship primitives, not pages. Treat data as memory, not exhaust. Put risk where the decisions are. Give developers a graph, not a maze. Do these well and the platform fades into the background-the merchant sees only a business that runs smoother, learns faster, and grows with less friction.
Leave a Reply