Founding Engineer

SENDIT Markets needed to build a full-stack marketplace from scratch — not just a frontend, but the entire infrastructure to support thousands of sellers listing digital goods, managing orders, and receiving payments. The founding team had a clear product vision but no engineering foundation.

The core challenge was building a system that felt as fast and intuitive as a traditional e-commerce platform while handling complex payment flows and secure server-side processing. Sellers needed to onboard in minutes, not hours. Buyers needed to checkout without friction, with the platform transparently handling all the payment complexity on the backend.

I designed a layered full-stack architecture with two separate Next.js applications — a buyer-facing marketplace and a seller dashboard — both built in TypeScript. The buyer app relied heavily on React Query for server state management, giving us optimistic updates and automatic cache invalidation. The seller dashboard was highly complex and required robust state handling for a multi-step onboarding wizard that needed to survive page refreshes and cross-device sessions.

The Go backend (Echo framework) ran as a set of independent microservices — Order, Product, Analytics, and User — each backed by PostgreSQL via GORM. Products were indexed into Elasticsearch for fast discovery, with mutations propagated via a RabbitMQ + Kafka hybrid messaging pipeline that kept the search index eventually consistent without blocking write paths.

// hooks/useChatSubscription.ts
// Bridges Pusher WebSockets with React Query's client cache
export function useChatSubscription(channelId: string) {
  const queryClient = useQueryClient();

  useEffect(() => {
    // 1. Connect to the authenticated Pusher instance
    const pusher = new Pusher(process.env.NEXT_PUBLIC_PUSHER_KEY!, {
      cluster: process.env.NEXT_PUBLIC_PUSHER_CLUSTER!,
      authEndpoint: "/api/pusher/auth",
    });

    // 2. Subscribe to the private chat channel
    const channel = pusher.subscribe(`private-chat-${channelId}`);

    // 3. Listen for new messages and merge them into the cache
    channel.bind("new-message", (newMessage: MessageData) => {
      queryClient.setQueryData(["chat-messages", channelId], (oldCache: any) => {
        if (!oldCache) return [newMessage];
        return [...oldCache, newMessage];
      });
    });

    // 4. Cleanup to prevent memory leaks on unmount
    return () => {
      pusher.unsubscribe(`private-chat-${channelId}`);
      pusher.disconnect();
    };
  }, [channelId, queryClient]);
}

Several architectural decisions defined the shape of this system:

• React Query over Redux or Zustand — Because the marketplace was extremely read-heavy, we treated server state and client state as fundamentally different concerns. React Query gave us automatic cache invalidation and optimistic mutations without the boilerplate of a global state manager. By leveraging its prefetching capabilities to load data before a user even clicked a link, we drastically improved perceived speeds and eliminated UI lag.
• Next.js API Routes for payment processing — Rather than exposing private keys or relying solely on the Go backend for transaction co-signing, we built a thin but critical server-side layer in Next.js. The /api/sponsor-transaction route validates incoming transaction instructions, verifies no unauthorized fund transfers are being attempted, and securely co-signs using a server-managed fee payer wallet before broadcasting — keeping the entire security surface contained.
• Go + Echo for microservices— The marketplace needed to handle concurrent order processing and real-time inventory locks across multiple sellers simultaneously. Go's goroutine model made this natural. The RabbitMQ + Kafka hybrid pipeline let us decouple write operations from search indexing, so Elasticsearch updates never blocked the critical order path.
• Gasless UX as a product requirement — We made a deliberate decision that buyers should never need to worry about gas fees or native token balances. The sponsor-transaction pattern achieved this by having the server absorb transaction fees, removing the biggest friction point in the checkout flow.
• Real-time Messaging System — We built a fully featured chat service allowing direct buyer-to-seller communication. Backed by PostgreSQL and leveraging Pusher for WebSocket connections, the system handled real-time message delivery, secure file sharing via MinIO, and unread notifications at scale, completely decoupling communication from the core transactional microservices.

While the backend handled the complex logic, the buyer-facing marketplace needed to be incredibly fast and visually engaging. We focused heavily on performance optimization and smooth interactions to ensure buyers could browse thousands of listings without lag.

I implemented advanced filtering and search backed by Elasticsearch, with URL-state-driven filters so users could share exact query views. The grid layouts were carefully optimized to maintain smooth scrolling even on mobile devices.

Slide 1 of 7

Marketplace Discovery Feed & Landing

The Seller Dashboard was the most complex frontend surface. It needed to support the full lifecycle: onboarding, identity verification, listing creation, order management, and analytics. I built it as a robust multi-step wizard, so sellers could start onboarding on their phone and finish on desktop without losing progress.

Slide 1 of 6

Seller Store Analytics & Metrics Dashboard

The analytics module used Recharts + D3to visualize seller performance metrics — revenue trends, order volume, average fulfillment time — driven by the Go backend's PostgreSQL Materialized Views. Product listings used Tiptap for rich text editing and Uploadcare for media management, keeping the listing creation flow seamless even for non-technical sellers.

Over 12 months as the founding engineer, the platform grew from zero to a functioning marketplace with measurable traction:

Beyond the metrics, the experience shaped how I think about building products from scratch — making pragmatic technical decisions under constraints, collaborating directly with founders on product direction, and shipping quickly without sacrificing the engineering foundation.