Fuul Webapp

Fuul Webapp is the project-owner console for Fuul, a multi-chain referral and incentives platform. It gives teams one place to configure reward programs, connect them to user actions, define audiences and tiers, fund campaign budgets, monitor performance, approve payouts, and reconcile invoices.

I worked on the product as a Senior Frontend Engineer and Design Engineer, owning key areas of the admin console over a long-running product cycle. My work focused on turning complex Web3 incentive operations into clear, self-service product flows for non-engineer operators.

Why this project matters

Running an incentive program in Web3 is operationally complex. A team needs to decide which actions should be rewarded, who qualifies, how much each participant earns, which chain or protocol the action belongs to, how budgets are funded, and how payouts are approved later.

Without a strong admin console, these workflows depend heavily on internal support, custom configuration, and engineering intervention. Fuul Webapp was built to make that lifecycle self-service.

The challenge was not just to add more screens. The challenge was to design a product foundation that could support many different reward models, protocol integrations, financial states, and edge cases without becoming fragmented.

My role

I was one of the main frontend owners of the Fuul Webapp experience. I worked across product, design, frontend architecture, backend integration, SDK usage, and production reliability.

My responsibilities included:

• Building product flows for incentives, conversions, triggers, tiers, audiences, payouts, claims, invoices, analytics, budget alerts, user management, and page customization.
• Creating reusable UI systems for tables, filters, drawers, forms, modals, empty states, status indicators, and detail views.
• Translating complex reward logic into guided, validated interfaces that operators could understand and use safely.
• Using Storybook to document reusable components and review important UI states.
• Contributing feature-scoped backend and SDK work when the frontend required new endpoints, data contracts, or integration support.
• Helping improve production stability around wallet libraries, routing behavior, chain handling, and cross-service consistency.

Product problem

Fuul needed a console that could support a growing set of incentive mechanics:

• Fixed, variable, pool, leaderboard, tiered, and multi-level affiliate reward structures.
• On-chain and off-chain triggers across multiple networks and partner integrations.
• Segmented audiences, eligibility rules, caps, payout terms, and budget thresholds.
• Heavy operational data: activity feeds, leaderboards, payout records, user histories, claims, invoices, and analytics.
• High-impact actions such as closing periods, generating invoices, approving payouts, and executing claims.

For recruiters, this project shows long-term product ownership in a complex B2B SaaS environment. For technical reviewers, it shows frontend architecture work across data-heavy interfaces, Web3 integrations, state management, validation, and reusable product systems.

Approach

I treated the admin console as a product platform rather than a collection of independent pages.

The main idea was to create reusable foundations that could support new business logic without forcing every feature to reinvent its UI patterns. This meant aligning feature modules around shared conventions for data fetching, local workflow state, forms, validation, table configuration, filters, drawers, and status handling.

The principles behind my work were:

1. Make complex configuration feel guided

Incentive programs can contain a lot of logic: reward type, trigger type, audience, payout terms, tiers, caps, timing, and funding. I focused on breaking these decisions into flows that progressively reveal complexity instead of exposing everything at once.

2. Build reusable operational patterns

Many parts of the product are data-heavy: payouts, claims, users, activity, invoices, leaderboards, and analytics. I helped create reusable table and detail-view patterns so operators could search, filter, inspect, and act on records consistently across the app.

3. Design for safe financial actions

Several workflows involve money movement, payout approval, budget usage, or billing. These flows needed clear states, defensive UI, confirmation patterns, and plain-language explanations so users understood the consequences of their actions.

4. Own features end-to-end when needed

Some features required more than frontend implementation. When a product surface needed new data access, SDK support, or infrastructure fixes, I contributed outside the frontend boundary to help ship the complete user experience.

Selected contributions

Incentive builder

I worked on the core incentive-configuration experience where project teams define how rewards work. This included fixed, variable, pool, leaderboard, tiered, and multi-level reward structures, as well as payout terms, distribution rules, and validation logic.

The goal was to turn complex incentive economics into an interface that could be configured by operators without needing a developer to manually set up every campaign.

Triggers and conversions

I contributed to the trigger and conversion configuration systems that connect reward programs to user actions. These flows needed to support many different action types while still feeling like one coherent product experience.

This required flexible form patterns, schema-driven thinking, careful validation, and strong type handling across frontend and API boundaries.

Tiers, audiences, and eligibility

I worked on segmentation tools that let operators define who qualifies for rewards and how different users or affiliates should be treated. This included audience conditions, tier logic, amount and multiplier modes, caps, and multi-audience flows.

These features helped the product support more advanced incentive strategies without making the configuration experience harder to understand.

Claims and payouts

I contributed to the lifecycle surfaces around earned rewards, open claims, closed claims, payout approval, and claim execution.

Because these workflows are financially meaningful, I focused on clear state communication, readable records, filtering, detail drawers, and safer action flows.

Invoices and billing

I built the invoices and billing experience, including invoice lists, KPI summaries, close-period flows, the generate-invoices flow, detail drawers, PDF download, regeneration, and open-in-new-tab behavior.

When PDF downloads were blocked by infrastructure configuration, I also helped resolve the S3 CORS issue so the feature could work end-to-end.

Budget alerts

I shipped the budget-alert settings experience, allowing operators to configure depletion thresholds and better understand when an incentive budget is at risk.

This improved the clarity of an important operational workflow: knowing when a campaign is approaching a funding problem before it affects participants.

User detail and audit views

I delivered user-level admin detail views with expandable payout-history rows, helping operators inspect individual reward activity more easily.

This work included component states, Storybook coverage, and tests so the interface could be reviewed and maintained with more confidence.

Affiliate application builder

I built a drag-and-drop affiliate-application form builder with field-type selection, live preview, validation, unsaved-change protection, and reusable sticky actions.

This gave operators a way to customize applicant-facing forms without requiring engineering changes.

Multi-chain platform work

I contributed to multi-chain product stability, including standardizing chain handling across services and helping onboard additional networks.

I also worked with wallet tooling such as Dynamic.xyz, wagmi, and viem, including diagnosing and mitigating production issues caused by upstream wallet-library changes.

Outcome

Fuul Webapp evolved into a full self-service admin console for running multi-chain incentive programs. Operators can configure reward logic, connect actions, segment users, fund budgets, monitor activity, approve payouts, and manage billing from one product surface.

My work helped the product scale from individual feature flows into a more coherent operating system for incentives. The strongest result was not a single screen, but the foundation: reusable frontend patterns that made it easier to keep adding complex product areas while preserving consistency and maintainability.

Links

• Website — fuul.xyz
• Company — kuyen.xyz
• Fuul SDK — github.com/kuyen-labs/fuul-sdk