LiveBid Platform

Inspiration

We wanted to explore how far we could go building a real-time application without relying on a backend. Auctions are a perfect use case for real-time interaction, synchronization, and conflict resolution. At the same time, we were curious about peer-to-peer technologies like Hyperswarm and Autopass, and how they could replace traditional server architectures.

What it does

LiveBid is a real-time auction platform where users can create and join auction rooms without any central server.

A host creates an auction session
Participants join using a code
Users can place bids in real time
The host validates bids and manages the auction
All state is synchronized across peers using P2P networking

How we built it

We built LiveBid using:

Electron + Pear for the desktop app Hyperswarm for peer discovery and networking Hypercore for replicating the official event log Autopass for handling user input requests Vanilla JS + HTML/CSS for the UI A custom event-driven architecture to manage auction state

The system follows a host-authoritative model, where only the host writes official events, ensuring consistency across all peers.

Challenges we ran into

Handling duplicate messages from multiple P2P channels Designing a consistent state model without a backend Managing real-time synchronization across peers Dealing with large payloads (e.g., images in Base64) Debugging networking behavior in a decentralized environment

Accomplishments that we're proud of

Building a fully working P2P app with no backend Achieving real-time synchronization between peers Designing a clean event-based architecture Implementing a host-authoritative model to avoid conflicts Successfully integrating Hyperswarm, Hypercore, and Autopass

What we learned

How peer-to-peer systems differ from traditional client-server apps The importance of event sourcing and deterministic state Challenges of network reliability and message deduplication How to structure a real-time app without centralized control Practical usage of the Holepunch ecosystem

What's next for LiveBid Platform

Improve UX (QR codes, cleaner join flow) Optimize data transfer (avoid large payloads like Base64 images) Add more auction features (timers, multiple lots, history) Strengthen security and identity handling

Readme file about the project

Team Structure

The project was divided into three main areas:

Students 1 & 4 → UI and navigation (HTML, CSS and JS). Student 2 → Core logic (events, rules, reducers and validation). Student 3 → P2P networking (Hyperswarm, Autopass and channels).

Overview

Our app is a fully peer-to-peer real-time auction platform built with:

Electron + Pear Hyperswarm & Hypercore Autopass

No backend and no servers, everything with peer to peer.

Dynamics

A host creates an auction session
A join code / QR is generated
Bidders connect using that code
A join request is given and approval flow is executed
All participants receive real-time updates
Only the host can validate bids and publish official events
State is synchronized across peers via P2P replication

User Flow

The host creates a session The bidder joins using join code The bidder sends a JOIN_REQUEST The host approves and the participant is approved (PARTICIPANT_APPROVED) The bidder sends a bid request (BID_REQUEST) The host validates and emits a BID_ACCEPTED or BID_REJECTED All clients update state via replicated events

Architecture

The system uses a dual P2P model:

Official State (source of truth): stored in a Hypercore log, replicated via Hyperswarm where only the host writes.
User Inputs (requests): handled through two channels:

a. Autopass (persistent input channel, used for JOIN and BID requests) b. Direct swarm sockets (real-time responsiveness)

Authority model

The host is authoritative Clients never modify state directly All changes must go through a request, followed by a validation and ending in an official event. This prevents conflicts

Key features

Real-time bidding and no backend required Deterministic state via event sourcing

Future Work

We explored extending this architecture into a real-time meeting platform

The same P2P structure could support a participant join/approval, real-time events and shared state synchronization.

Summary documentation

We use Hyperswarm for decentralized peer discovery via shared topics embedded in a joinCode. Write authorization follows a host-authoritative model where only the host writes to the shared log, while clients send requests through Autopass and sockets. This is reflected in the UX as a request-validation-confirmation flow.