KompiPay — brand-first payments

The goal of KompiPay was to solve a specific but widespread problem: many businesses want a custom website and a clean checkout experience, but don’t want to adopt an entire commerce platform to achieve it.

Existing tools often force merchants into trade-offs between control and convenience, either requiring deep technical work or pushing them into rigid, brand-heavy ecosystems.

KompiPay was designed as a checkout-first product that focuses purely on the act of paying. By narrowing the scope intentionally, the platform could remain lightweight, easy to adopt, and commercially viable from day one through a hybrid subscription and transaction-based model.

Every decision was made to avoid feature bloat and to keep the product extensible without becoming opinionated about how businesses sell.

KompiPay is designed for two users, each with very different needs at the same moment.

For customers, the goal was to create a payment experience that feels calm, trustworthy, and frictionless. Paying should feel like a natural conclusion to a decision, not a stressful or confusing process.

The checkout experience avoids visual noise, aggressive branding, and dark patterns, allowing customers to focus on completing their payment with confidence.

For merchants, KompiPay aims to make accepting payments feel simple and empowering. They can keep their existing website, storytelling, and brand identity, while relying on KompiPay to handle the complexity of checkout, payment confirmation, and order handling behind the scenes.

Early in the project, I made a deliberate decision to reset how the product was framed.

Rather than designing KompiPay around a specific niche or first client, I defined a clear north star: KompiPay should feel like PayPal in its early years.

Not a wallet, not a marketplace, and not a store builder — but a simple and reliable way to request and complete payments online.

This framing became a critical design and product guardrail. It meant saying no to carts, subscriptions, storefronts, and discovery features, even when they felt tempting.

By focusing solely on payment moments, the product stayed coherent, shippable, and scalable across different industries without losing its identity.

I began by exploring where existing payment and commerce tools create friction, both for businesses and for customers. Through analysis and early experimentation, it became clear that most complexity comes not from payments themselves, but from the layers built around them.

From there, I mapped the entire payment journey, from order creation through to confirmation and post-payment communication.

Rather than designing screens in isolation, I designed the underlying system that supports them, ensuring that the user experience, backend logic, and payment provider all aligned around a single source of truth.

I then translated this thinking into a clear functional specification and platform architecture. This included defining the data models, order lifecycle, API boundaries, and integration strategy with Stripe.

These decisions weren’t just technical; they directly shaped the user experience by making the platform faster, safer, and easier to reason about.

Visually, KompiPay was designed to feel calm, minimal, and editorial. The interface avoids unnecessary decoration and prioritises typography, spacing, and restraint.

The goal was to create a checkout experience that respects the seriousness of a financial transaction and gives space to the merchant’s brand rather than competing with it.

Branding within the checkout is intentionally subtle. KompiPay acts as a quiet trust layer, allowing merchants to apply their own identity without overwhelming the user.

Alongside the design work, I built the platform itself. This included setting up the database, implementing the API routes, creating the hosted checkout experience, and deploying the system to production.

I handled environment setup, domain configuration, and production hardening, ensuring the platform was stable and ready to support real transactions.

Throughout the build, I documented decisions and maintained a clear run log so the project could scale beyond a single contributor.

The result is a working, deployed platform with a locked schema, clear extension points, and a roadmap for future development.

This was not a handoff project or a concept exercise. I acted as the product lead, designer, and builder throughout, making decisions across strategy, design, and engineering.

I defined what the product should be, how it should feel, and how it should work — then built it to that standard.

The project reflects how I approach product leadership: setting clear boundaries, designing systems rather than features, and shipping things that work in the real world.

KompiPay now exists as a focused payments platform with a clear identity, a working foundation, and a defined path forward.

The next phase of the product will expand the types of payment moments it supports, such as invoices and deposits, without compromising the core philosophy or simplicity of the platform.

KompiPay demonstrates my ability to lead a product from first principles through to production.

It shows how I think about scope, user trust, system design, and execution — and how design decisions extend far beyond the interface.

It’s the kind of work that reflects how I operate as a lead product designer: calm, opinionated, and focused on building the right thing, not the biggest thing.