000
Compiling the experience

Chapter 01 — May 2023 — Sep 2025

Konin Cloud.

Payments, a wallet, and a stack that had to last.

Role
Senior Frontend Developer
When
May 2023 — Sep 2025
Where
Full-time · Remote
Product
KoninPay, a multi-store SaaS platform

( 01 ) — The context

KoninPay lets merchants create stores, run platform operations, take payments and use a dedicated digital wallet. When money moves through the UI, a broken flow costs far more than a broken button, so a lot of my work happened underneath the screens: the stack, the data and the tests.

  • Next.js

    the foundation I advocated, with a written comparison

  • 7

    live storefronts running on the platform

  • E2E

    plus RTL, integration and manual testing on critical flows

( 02 ) — The role

What I owned.

Senior Frontend Developer · Full-time · Remote

  1. 01

    Advocated Next.js over the initially proposed HTML, Sass and Blade approach, and prepared the technical comparison behind the decision.

  2. 02

    Built reusable, responsive UI components from Figma and integrated REST APIs with structured loading and error states.

  3. 03

    Tested critical flows with React Testing Library, integration, end-to-end and manual testing.

  4. 04

    Reviewed API request/response behavior, response performance and logs, and optimized data fetching to cut unnecessary payloads.

  5. 05

    Improved performance through Lighthouse analysis, code splitting, lazy loading and asset optimization.

ReactNext.jsTypeScriptMaterial UISassREST APIsReact Testing Library

( 03 ) — Stories

What happened.

9 stories from Konin Cloud: the problem, what I did, what came of it.

Arguing for Next.js, in writing

ArchitectureCollaboration

The problem

The initial plan for KoninPay was HTML, Sass and Blade, for a product with merchant and store creation, payments and a wallet that had to keep growing.

What I did

I advocated Next.js, focusing on scalability, maintainability, development efficiency and long-term product evolution, and wrote a technical comparison of both approaches: architecture, advantages, trade-offs and maintainability. Part of the case was SEO: storefront product pages needed proper titles and link previews, and with Next.js they render on the server with their own metadata.

Result

The comparison supported the team's technology decision. Product pages became shareable and indexable, and seven live storefronts run on the platform today.

The call

Build the platform on Next.js

Instead of: HTML, Sass and Blade

Scalability, maintainability, development speed, and product pages that render with their own metadata for SEO and link previews.

A written comparison persuades better than an opinion, especially for people outside frontend.

Read the full case study→

Test the paths that move money first

Quality

The problem

In a product with payment workflows and a digital wallet, release bugs hide in the flows nobody clicks through before shipping, and a broken checkout costs far more than a broken button.

What I did

I tested critical flows with React Testing Library, integration testing, end-to-end testing and manual validation before releases, across user flows, UI behavior and API interactions.

Result

Releases were checked where a mistake would cost the most.

The call

Put the money paths at the top of the test plan

Instead of: Spreading testing evenly across every screen

Payments and the wallet are where a bug costs merchants and customers real money.

On money flows, test the flows, not just the components.

One click, one payment

QualityCollaboration

The problem

A fast double click could send the same payment request twice.

What I did

I disabled the button while the request ran and agreed a duplicate-request check with the backend team, so the protection didn't depend on the UI alone.

Result

There were no duplicate requests in testing.

Guard money on both sides of the API.

The wallet balance that lagged behind

QualityUX & product

The problem

After a payment, the wallet balance on screen could stay old until a refresh.

What I did

I refetched the balance when the payment finished and showed a pending state in between.

Result

The balance on screen matched the real one.

A number on screen is a promise. Show pending rather than show wrong.

The bug that only Safari saw

Quality

The problem

A layout broke only in Safari, with a release coming.

What I did

Cross-browser checks before the release caught it, and I fixed it with a fallback before shipping.

Result

Users never saw it.

Test the browser nobody on the team uses.

Fetch what you render

PerformanceCollaboration

The problem

A product grid that showed a name, a price and a thumbnail was loading full product objects.

What I did

I compared what the screens fetched with what they rendered and worked with the backend team on a lighter list response, as part of optimizing data-fetching patterns across the platform.

Result

Lighter pages and faster scrolling.

Compare what you fetch with what you render.

One way to load, fail and retry

ArchitectureUX & product

The problem

Every screen handled loading and errors its own way.

What I did

I built shared skeleton, empty-state and error-with-retry components and used them everywhere.

Result

Consistent screens, and new screens became faster to build.

Design the unhappy states once, then reuse them.

Store setup in steps, not one long form

UX & product

The problem

Merchants had to fill one long form to create a store.

What I did

I split it into steps with validation per step, so errors showed where they happened.

Result

Store setup became easier to finish and easier to support.

Put the error next to the field that caused it.

Wrong data on screen: frontend or API?

CollaborationQuality

The problem

Wrong data on screen raises one question first: is it the frontend or the API?

What I did

Supporting production reliability meant reviewing API requests, responses, response performance and application and server logs before raising anything.

Result

Issues reached the backend team with evidence attached, not "it's broken".

Check the payload first, then bring evidence.

What I took from it: Test the paths that move money first, and bring evidence, not opinions.

Next chapter · 02

The Sailors→