updated

2026-04-14 18:31:48 +01:00
42 changed files with 8759 additions and 2127 deletions
--- a/README.md
+++ b/README.md
@@ -1,57 +1,280 @@
+
 # P2P Poll App

-A peer-to-peer polling application where users can create polls, add options, and vote in real-time without a central server.
+A peer-to-peer polling application built with React, TypeScript, Tailwind CSS, Node.js, Yjs, and WebSocket for real-time collaborative voting.
+
+**Users can create polls, add answers, and vote in real-time with automatic P2P synchronization across all connected clients.**
+
+## Architecture
+
+**Hybrid P2P Approach:**
+- Backend serves as both a Yjs WebSocket provider (for state synchronization) and signaling server (for WebRTC peer discovery)
+- Clients sync poll data via Yjs CRDT for conflict-free merging
+- Direct P2P connections via WebRTC for real-time updates when possible
+- Server fallback ensures reliability when P2P fails
+
+## Tech Stack
+
+**Backend:**
+- Node.js + TypeScript
+- Express.js
+- WebSocket (ws)
+- y-websocket (Yjs WebSocket provider)
+- CORS support
+
+**Frontend:**
+- React 18 + TypeScript
+- Vite (build tool)
+- Tailwind CSS
+- Yjs (CRDT library)
+- y-websocket (server sync)
+- y-webrtc (P2P sync)
+- lucide-react (icons)
+
+## Project Structure
+
+```
+quicgroup/
+├── server/                 # Backend Node.js server
+│   ├── src/
+│   │   ├── index.ts       # Main server entry
+│   │   ├── yjs-server.ts  # Yjs WebSocket provider
+│   │   ├── signaling-server.ts  # WebRTC signaling
+│   │   ├── types/         # TypeScript types
+│   │   └── utils/         # Utilities
+│   ├── package.json
+│   └── tsconfig.json
+│
+└── frontend/              # React frontend
+    ├── src/
+    │   ├── components/    # React components
+    │   ├── hooks/         # Custom React hooks
+    │   ├── lib/           # Yjs setup and utilities
+    │   ├── types/         # TypeScript types
+    │   └── styles/        # CSS styles
+    ├── package.json
+    └── vite.config.ts
+```
+
+## Setup Instructions
+
+### Prerequisites
+- Node.js 18+ and npm
+
+### Backend Setup
+
+1. Navigate to server directory:
+```bash
+cd server
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Copy environment file:
+```bash
+cp .env.example .env
+```
+
+4. Start the development server:
+```bash
+npm run dev
+```
+
+The server will run on `http://localhost:3000` with:
+- Yjs WebSocket: `ws://localhost:3000/yjs`
+- Signaling WebSocket: `ws://localhost:3000/signal`
+
+### Frontend Setup
+
+1. Navigate to frontend directory:
+```bash
+cd frontend
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Copy environment file (optional):
+```bash
+cp .env.example .env
+```
+
+4. Start the development server:
+```bash
+npm run dev
+```
+
+The frontend will run on `http://localhost:5173`
+
+## Running the Application
+
+1. **Start Backend** (Terminal 1):
+```bash
+cd server
+npm run dev
+```
+
+2. **Start Frontend** (Terminal 2):
+```bash
+cd frontend
+npm run dev
+```
+
+3. **Open Browser:**
+   - Navigate to `http://localhost:5173`
+   - Open multiple tabs/windows to test P2P synchronization

 ## Features

- **Real-time P2P voting** using WebRTC via PeerJS
- **Dynamic option management** - add/remove options during polling
- **Duplicate vote prevention** - one vote per user
- **Automatic data synchronization** across all connected peers
- **Local storage persistence** for poll recovery
- **Responsive design** works on desktop and mobile
- **No server required** - uses PeerJS free signaling service
+### Dynamic Poll Creation
+- **Create Polls** - Any user can create new polls with custom questions
+- **Add Answers** - Anyone can add answer options to any poll
+- **Real-time Voting** - Vote on options with instant updates across all clients
+- **Smart Vote Tracking** - One vote per user per option (prevents duplicate voting)
+- **Visual Feedback** - Green border and " Voted" indicator on voted options
+- **User Attribution** - See who created each poll and option
+- **Live Vote Counts** - See vote percentages and counts update in real-time
+- **P2P Synchronization** - Uses Yjs CRDT for conflict-free state merging
+- **Connection Status** - Visual indicator showing WebSocket and peer connections
+- **Hybrid Architecture** - Combines WebSocket server sync with WebRTC P2P
+- **Beautiful UI** - Modern gradient design with Tailwind CSS

 ## How to Use

-1. **Open the app** in your browser (open `index.html`)
-2. **First user (Host)**: Leave the Peer ID field empty and click "Connect to Host"
-3. **Copy your Peer ID** using the "Copy Your Peer ID" button
-4. **Share your Peer ID** with other users (via chat, email, etc.)
-5. **Other users**: Paste the host's Peer ID and click "Connect to Host"
-6. **Create a poll** with question and options
-7. **Vote** by clicking on options (one vote per person)
-8. **Watch results** update in real-time across all devices
+### Create a Poll
+1. Enter your question in the "Create a New Poll" form at the top
+2. Click "Create Poll"
+3. Your poll appears instantly for all connected users

-## Technical Details
+### Add Answer Options
+1. Find the poll you want to add an answer to
+2. Type your answer in the "Add a new option..." field
+3. Click "Add"
+4. Your answer appears instantly for all users

- **P2P Library**: PeerJS (WebRTC-based)
- **Frontend**: Vanilla JavaScript with modern CSS
- **Data Sync**: Custom conflict resolution for concurrent operations
- **Storage**: localStorage for basic persistence
- **Network**: Full mesh topology where each peer connects to all others
+### Vote on Options
+1. Click the vote button (thumbs up icon) on any option
+2. You can only vote once per option
+3. Voted options show a green border and " Voted" indicator
+4. Vote counts update in real-time across all clients

-## File Structure
+### Multi-User Testing
+1. Open multiple browser tabs/windows
+2. Create polls from different tabs
+3. Add answers from different tabs
+4. Vote from different tabs
+5. Watch real-time synchronization in action!

-```
-├── index.html              # Main application
-├── css/
-│   └── styles.css          # Application styling
-└── js/
-    ├── app.js              # Main application logic
-    ├── peer-manager.js     # P2P connection handling
-    ├── poll-manager.js     # Poll data and sync logic
-    └── ui-controller.js    # UI interactions
+## How It Works
+
+### CRDT Synchronization
+The app uses Yjs (a CRDT library) to ensure all clients converge to the same state without conflicts:
+- Each client maintains a local Yjs document
+- Changes are automatically synced via WebSocket to the server
+- WebRTC provides direct P2P connections between clients
+- Yjs handles merge conflicts automatically
+- One vote per user per option is enforced via `votedBy` tracking
+
+## Data Model
+```typescript
+{
+  polls: Array<{
+    id: string,
+    question: string,
+    createdBy: string,
+    timestamp: number,
+    options: Array<{
+      id: string,
+      text: string,
+      votes: number,
+      votedBy: string[],  // Tracks which users have voted
+      createdBy: string,
+      timestamp: number
+    }>
+  }>
+}
 ```

-## Browser Support
+## Testing P2P Functionality

-Requires modern browsers with WebRTC support:
- Chrome 23+
- Firefox 22+
- Safari 11+
- Edge 79+
+1. Open the app in multiple browser tabs/windows
+2. **Create polls** from different tabs - they appear everywhere instantly
+3. **Add answer options** from different tabs to the same poll
+4. **Vote** from different tabs - watch vote counts update in real-time
+5. Try voting twice on the same option - it won't let you!
+6. Check the connection status indicator for peer count
+7. Verify visual feedback (green border) on options you've voted on

 ## Development

-Simply open `index.html` in a browser - no build process required. For testing with multiple peers, open the app in multiple browser tabs or windows.
+### Backend Scripts
+- `npm run dev` - Start development server with hot reload
+- `npm run build` - Build for production
+- `npm start` - Run production build
+
+### Frontend Scripts
+- `npm run dev` - Start Vite dev server
+- `npm run build` - Build for production
+- `npm run preview` - Preview production build
+
+## Environment Variables
+
+### Backend (.env)
+```
+PORT=3000
+YJS_WS_PORT=1234
+NODE_ENV=development
+CORS_ORIGIN=http://localhost:5173
+```
+
+### Frontend (.env)
+```
+VITE_WS_URL=ws://localhost:3000
+```
+
+## Components
+
+### Frontend Components
+- **PollView** - Main view showing all polls and create poll form
+- **CreatePoll** - Form to create new polls
+- **PollCard** - Individual poll display with metadata
+- **OptionList** - List of answer options with vote tracking
+- **AddOption** - Form to add new answer options
+- **VoteButton** - Vote button with disabled state for voted options
+- **ConnectionStatus** - Shows WebSocket and P2P connection status
+
+### Key Functions
+- `createPoll(question)` - Create a new poll
+- `addOption(pollId, text)` - Add an option to a specific poll
+- `vote(pollId, optionId)` - Vote on an option (one vote per user)
+- `hasVoted(option)` - Check if current user has voted on an option
+
+## User Tracking
+
+Each user gets a unique ID stored in localStorage:
+- Format: `user-xxxxxxxxx`
+- Used to track poll/option creators
+- Used to prevent duplicate voting
+- Persists across browser sessions
+
+## Future Enhancements
+
+- [ ] Edit/delete polls and options
+- [ ] User nicknames instead of IDs
+- [ ] Poll expiration/closing
+- [ ] Vote history and analytics
+- [ ] Export poll results
+- [ ] Persistent storage (database)
+- [ ] Dark mode toggle
+- [ ] Mobile responsive improvements
+- [ ] Poll categories/tags
+- [ ] Search/filter polls
+
+## License
+
+MIT
--- a/css/styles.css
+++ b/css/styles.css
@@ -1,665 +0,0 @@
-* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-}
-
-body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    min-height: 100vh;
-    color: #333;
-}
-
-.container {
-    max-width: 1200px;
-    margin: 0 auto;
-    padding: 20px;
-}
-
-.main-content {
-    display: grid;
-    grid-template-columns: 280px 1fr;
-    gap: 20px;
-    margin-top: 20px;
-}
-
-.sidebar {
-    display: flex;
-    flex-direction: column;
-    gap: 20px;
-}
-
-.sidebar-section {
-    background: white;
-    border-radius: 12px;
-    padding: 20px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-
-.sidebar-section h3 {
-    margin: 0 0 15px 0;
-    color: #333;
-    font-size: 1.1rem;
-}
-
-.sidebar-hint {
-    margin-bottom: 10px;
-}
-
-.hint-text {
-    font-size: 0.8rem;
-    color: #6b7280;
-    font-style: italic;
-    text-align: center;
-    padding: 8px;
-    background: #f9fafb;
-    border-radius: 6px;
-    border: 1px solid #e5e7eb;
-}
-
-.polls-list {
-    max-height: 300px;
-    overflow-y: auto;
-}
-
-.poll-item {
-    padding: 12px;
-    border: 1px solid #e5e7eb;
-    border-radius: 8px;
-    margin-bottom: 8px;
-    cursor: pointer;
-    transition: all 0.3s;
-    position: relative;
-}
-
-.poll-item:hover {
-    border-color: #667eea;
-    background: #f9fafb;
-    transform: translateY(-1px);
-}
-
-.poll-item.active {
-    border-color: #667eea;
-    background: #ede9fe;
-}
-
-.poll-item-title {
-    font-weight: 500;
-    color: #333;
-    margin-bottom: 4px;
-}
-
-.poll-item-meta {
-    font-size: 0.8rem;
-    color: #6b7280;
-}
-
-.poll-item::after {
-    content: ">";
-    position: absolute;
-    right: 12px;
-    top: 50%;
-    transform: translateY(-50%);
-    color: #9ca3af;
-    font-size: 0.8rem;
-    opacity: 0;
-    transition: opacity 0.3s;
-}
-
-.poll-item:hover::after {
-    opacity: 1;
-}
-
-.no-polls {
-    color: #9ca3af;
-    font-style: italic;
-    text-align: center;
-    padding: 20px 0;
-}
-
-.peers-info {
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-}
-
-.peers-status {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    font-size: 0.9rem;
-}
-
-.status-text {
-    padding: 2px 8px;
-    border-radius: 12px;
-    font-size: 0.8rem;
-    font-weight: 500;
-}
-
-.status-text.connected {
-    background: #dcfce7;
-    color: #16a34a;
-}
-
-.status-text.disconnected {
-    background: #fef2f2;
-    color: #dc2626;
-}
-
-.status-text.connecting {
-    background: #fef3c7;
-    color: #d97706;
-}
-
-.peers-sidebar {
-    list-style: none;
-    margin: 0;
-    padding: 0;
-    max-height: 150px;
-    overflow-y: auto;
-}
-
-.peers-sidebar li {
-    padding: 6px 0;
-    border-bottom: 1px solid #f3f4f6;
-    font-size: 0.9rem;
-    color: #6b7280;
-}
-
-.peers-sidebar li:last-child {
-    border-bottom: none;
-}
-
-header {
-    background: white;
-    border-radius: 12px;
-    padding: 20px;
-    margin-bottom: 20px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-}
-
-h1 {
-    color: #667eea;
-    font-size: 2rem;
-}
-
-.connection-status {
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    font-size: 0.9rem;
-}
-
-#peer-id {
-    background: #f0f0f0;
-    padding: 5px 10px;
-    border-radius: 6px;
-    font-family: monospace;
-    max-width: 150px;
-    overflow: hidden;
-    text-overflow: ellipsis;
-}
-
-.status-connected {
-    color: #10b981;
-}
-
-.status-disconnected {
-    color: #ef4444;
-}
-
-.status-connecting {
-    color: #f59e0b;
-}
-
-.section {
-    background: white;
-    border-radius: 12px;
-    padding: 20px;
-    margin-bottom: 20px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-
-.section.hidden {
-    display: none;
-}
-
-h2 {
-    color: #333;
-    margin-bottom: 20px;
-    font-size: 1.5rem;
-}
-
-h3 {
-    color: #666;
-    margin-bottom: 15px;
-    font-size: 1.1rem;
-}
-
-.connection-info {
-    background: #f0f9ff;
-    padding: 15px;
-    border-radius: 8px;
-    margin-bottom: 20px;
-    border-left: 4px solid #3b82f6;
-}
-
-.connection-info p {
-    margin: 5px 0;
-    font-size: 0.9rem;
-    color: #1e40af;
-}
-
-.connection-controls {
-    display: flex;
-    gap: 10px;
-    margin-bottom: 20px;
-    flex-wrap: wrap;
-}
-
-input[type="text"] {
-    flex: 1;
-    min-width: 200px;
-    padding: 12px;
-    border: 2px solid #e5e7eb;
-    border-radius: 8px;
-    font-size: 1rem;
-    transition: border-color 0.3s;
-}
-
-input[type="text"]:focus {
-    outline: none;
-    border-color: #667eea;
-}
-
-button {
-    background: #667eea;
-    color: white;
-    border: none;
-    padding: 12px 20px;
-    border-radius: 8px;
-    font-size: 1rem;
-    cursor: pointer;
-    transition: all 0.3s;
-}
-
-button:hover {
-    background: #5a67d8;
-    transform: translateY(-1px);
-}
-
-button:disabled {
-    background: #9ca3af;
-    cursor: not-allowed;
-    transform: none;
-}
-
-button.small-btn {
-    padding: 8px 12px;
-    font-size: 0.9rem;
-}
-
-button.danger {
-    background: #ef4444;
-}
-
-button.danger:hover {
-    background: #dc2626;
-}
-
-
-.poll-form {
-    display: flex;
-    flex-direction: column;
-    gap: 15px;
-}
-
-#options-container {
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-}
-
-.option-input {
-    display: flex;
-    gap: 10px;
-    align-items: center;
-}
-
-.option-text {
-    flex: 1;
-}
-
-.remove-option-btn {
-    background: #ef4444;
-    color: white;
-    border: none;
-    padding: 4px 8px;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 0.8rem;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    min-width: 60px;
-}
-
-.remove-option-btn.hidden {
-    display: none;
-}
-
-.poll-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 20px;
-}
-
-.vote-hint {
-    margin-bottom: 20px;
-}
-
-.vote-hint .hint-text {
-    font-size: 0.9rem;
-    color: #6b7280;
-    text-align: center;
-    padding: 10px;
-    background: #f0f9ff;
-    border-radius: 8px;
-    border: 1px solid #bfdbfe;
-}
-
-.options-list {
-    display: flex;
-    flex-direction: column;
-    gap: 15px;
-}
-
-.poll-option {
-    background: #f9fafb;
-    padding: 15px;
-    border-radius: 8px;
-    border: 2px solid transparent;
-    transition: all 0.3s;
-    cursor: pointer;
-    position: relative;
-}
-
-.poll-option:hover {
-    border-color: #667eea;
-    transform: translateY(-1px);
-}
-
-.poll-option.voted {
-    border-color: #10b981;
-    background: #ecfdf5;
-}
-
-.poll-option.voted::before {
-    content: "✓";
-    position: absolute;
-    top: 10px;
-    right: 10px;
-    background: #10b981;
-    color: white;
-    width: 20px;
-    height: 20px;
-    border-radius: 50%;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    font-size: 12px;
-    font-weight: bold;
-}
-
-.poll-option.change-vote {
-    border-color: #f59e0b;
-    background: #fffbeb;
-}
-
-.poll-option.change-vote:hover {
-    border-color: #d97706;
-}
-
-.option-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 10px;
-}
-
-.option-text {
-    font-weight: 500;
-    color: #333;
-}
-
-.vote-count {
-    background: #667eea;
-    color: white;
-    padding: 4px 8px;
-    border-radius: 12px;
-    font-size: 0.8rem;
-}
-
-.vote-bar {
-    background: #e5e7eb;
-    height: 8px;
-    border-radius: 4px;
-    overflow: hidden;
-}
-
-.vote-fill {
-    background: #667eea;
-    height: 100%;
-    transition: width 0.3s ease;
-}
-
-.poll-actions {
-    display: flex;
-    gap: 10px;
-    margin-top: 20px;
-}
-
-.overlay {
-    position: fixed;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: rgba(0, 0, 0, 0.5);
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    align-items: center;
-    z-index: 1000;
-}
-
-.overlay.hidden {
-    display: none;
-}
-
-.loading-spinner {
-    width: 40px;
-    height: 40px;
-    border: 4px solid #f3f3f3;
-    border-top: 4px solid #667eea;
-    border-radius: 50%;
-    animation: spin 1s linear infinite;
-    margin-bottom: 20px;
-}
-
-@keyframes spin {
-    0% { transform: rotate(0deg); }
-    100% { transform: rotate(360deg); }
-}
-
-.notification {
-    position: fixed;
-    top: 20px;
-    right: 20px;
-    background: #333;
-    color: white;
-    padding: 15px 20px;
-    border-radius: 8px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-    z-index: 1001;
-    max-width: 300px;
-}
-
-.notification.success {
-    background: #10b981;
-}
-
-.notification.error {
-    background: #ef4444;
-}
-
-.notification.hidden {
-    display: none;
-}
-
-/* Modal Styles */
-.modal {
-    position: fixed;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: rgba(0, 0, 0, 0.5);
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    z-index: 1002;
-}
-
-.modal.hidden {
-    display: none;
-}
-
-.modal-content {
-    background: white;
-    border-radius: 12px;
-    width: 90%;
-    max-width: 400px;
-    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
-    overflow: hidden;
-}
-
-.modal-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 20px;
-    border-bottom: 1px solid #e5e7eb;
-}
-
-.modal-header h3 {
-    margin: 0;
-    color: #333;
-    font-size: 1.2rem;
-}
-
-.modal-close {
-    background: none;
-    border: none;
-    font-size: 1.5rem;
-    color: #6b7280;
-    cursor: pointer;
-    padding: 0;
-    width: 30px;
-    height: 30px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    border-radius: 50%;
-    transition: all 0.3s;
-}
-
-.modal-close:hover {
-    background: #f3f4f6;
-    color: #374151;
-}
-
-.modal-body {
-    padding: 20px;
-}
-
-.modal-body input {
-    width: 100%;
-    padding: 12px;
-    border: 2px solid #e5e7eb;
-    border-radius: 8px;
-    font-size: 1rem;
-    transition: border-color 0.3s;
-}
-
-.modal-body input:focus {
-    outline: none;
-    border-color: #667eea;
-}
-
-.modal-footer {
-    padding: 20px;
-    border-top: 1px solid #e5e7eb;
-    display: flex;
-    gap: 10px;
-    justify-content: flex-end;
-}
-
-.btn-secondary {
-    background: #6b7280;
-    color: white;
-}
-
-.btn-secondary:hover {
-    background: #4b5563;
-}
-
-.btn-primary {
-    background: #667eea;
-    color: white;
-}
-
-.btn-primary:hover {
-    background: #5a67d8;
-}
-
-@media (max-width: 768px) {
-    .container {
-        padding: 10px;
-    }
-    
-    .main-content {
-        grid-template-columns: 1fr;
-        gap: 15px;
-    }
-    
-    .sidebar {
-        order: 2;
-    }
-    
-    main {
-        order: 1;
-    }
-    
-    header {
-        flex-direction: column;
-        gap: 15px;
-        text-align: center;
-    }
-    
-    .connection-controls {
-        flex-direction: column;
-    }
-    
-    .poll-header {
-        flex-direction: column;
-        gap: 10px;
-        align-items: flex-start;
-    }
-}
--- a/frontend/.env.example
+++ b/frontend/.env.example
@@ -0,0 +1 @@
+VITE_WS_URL=ws://localhost:5000
--- a/frontend/.gitignore
+++ b/frontend/.gitignore
@@ -0,0 +1,6 @@
+node_modules
+dist
+dist-ssr
+*.local
+.env
+.DS_Store
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>P2P Poll App</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "p2p-poll-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "yjs": "^13.6.8",
+    "y-websocket": "^1.5.0",
+    "y-webrtc": "^10.2.5",
+    "lucide-react": "^0.294.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.37",
+    "@types/react-dom": "^18.2.15",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "autoprefixer": "^10.4.16",
+    "eslint": "^8.53.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.4",
+    "postcss": "^8.4.31",
+    "tailwindcss": "^3.3.5",
+    "typescript": "^5.2.2",
+    "vite": "^5.0.0"
+  }
+}
--- a/frontend/postcss.config.js
+++ b/frontend/postcss.config.js
@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -0,0 +1,8 @@
+import { PollView } from './components/PollView';
+import './styles/index.css';
+
+function App() {
+  return <PollView />;
+}
+
+export default App;
--- a/frontend/src/components/AddOption.tsx
+++ b/frontend/src/components/AddOption.tsx
@@ -0,0 +1,38 @@
+import { useState } from 'react';
+import { Plus } from 'lucide-react';
+
+interface AddOptionProps {
+  onAdd: (text: string) => void;
+}
+
+export function AddOption({ onAdd }: AddOptionProps) {
+  const [text, setText] = useState('');
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (text.trim()) {
+      onAdd(text);
+      setText('');
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="flex gap-2">
+      <input
+        type="text"
+        value={text}
+        onChange={(e) => setText(e.target.value)}
+        placeholder="Add a new option..."
+        className="flex-1 px-4 py-3 rounded-lg bg-white/10 border border-white/20 text-white placeholder-white/50 focus:outline-none focus:ring-2 focus:ring-white/30"
+      />
+      <button
+        type="submit"
+        disabled={!text.trim()}
+        className="px-6 py-3 bg-white text-purple-600 rounded-lg font-semibold hover:bg-white/90 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 flex items-center gap-2"
+      >
+        <Plus className="w-5 h-5" />
+        Add
+      </button>
+    </form>
+  );
+}
--- a/frontend/src/components/ConnectionStatus.tsx
+++ b/frontend/src/components/ConnectionStatus.tsx
@@ -0,0 +1,34 @@
+import { Wifi, WifiOff, Users } from 'lucide-react';
+
+interface ConnectionStatusProps {
+  isConnected: boolean;
+  wsProvider: any;
+  webrtcProvider: any;
+}
+
+export function ConnectionStatus({ isConnected, wsProvider, webrtcProvider }: ConnectionStatusProps) {
+  const peerCount = webrtcProvider?.room?.peers?.size || 0;
+
+  return (
+    <div className="flex items-center gap-4 text-white/90 text-sm">
+      <div className="flex items-center gap-2">
+        {isConnected ? (
+          <>
+            <Wifi className="w-4 h-4 text-green-400" />
+            <span>Connected</span>
+          </>
+        ) : (
+          <>
+            <WifiOff className="w-4 h-4 text-red-400" />
+            <span>Disconnected</span>
+          </>
+        )}
+      </div>
+      
+      <div className="flex items-center gap-2">
+        <Users className="w-4 h-4" />
+        <span>{peerCount} peer{peerCount !== 1 ? 's' : ''}</span>
+      </div>
+    </div>
+  );
+}
--- a/frontend/src/components/CreatePoll.tsx
+++ b/frontend/src/components/CreatePoll.tsx
@@ -0,0 +1,43 @@
+import { useState } from 'react';
+import { Plus } from 'lucide-react';
+
+interface CreatePollProps {
+  onCreate: (question: string) => void;
+}
+
+export function CreatePoll({ onCreate }: CreatePollProps) {
+  const [question, setQuestion] = useState('');
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (question.trim()) {
+      onCreate(question);
+      setQuestion('');
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="mb-8">
+      <div className="bg-white/10 backdrop-blur-lg rounded-2xl shadow-2xl p-6 border border-white/20">
+        <h2 className="text-xl font-bold text-white mb-4">Create a New Poll</h2>
+        <div className="flex gap-2">
+          <input
+            type="text"
+            value={question}
+            onChange={(e) => setQuestion(e.target.value)}
+            placeholder="Enter your question..."
+            className="flex-1 px-4 py-3 rounded-lg bg-white/10 border border-white/20 text-white placeholder-white/50 focus:outline-none focus:ring-2 focus:ring-white/30"
+          />
+          <button
+            type="submit"
+            disabled={!question.trim()}
+            className="px-6 py-3 bg-white text-purple-600 rounded-lg font-semibold hover:bg-white/90 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 flex items-center gap-2"
+          >
+            <Plus className="w-5 h-5" />
+            Create Poll
+          </button>
+        </div>
+      </div>
+    </form>
+  );
+}
--- a/frontend/src/components/OptionList.tsx
+++ b/frontend/src/components/OptionList.tsx
@@ -0,0 +1,60 @@
+import { PollOption } from '../types/poll.types';
+import { VoteButton } from './VoteButton';
+
+interface OptionListProps {
+  options: PollOption[];
+  onVote: (optionId: string) => void;
+  hasVoted?: (option: PollOption) => boolean;
+}
+
+export function OptionList({ options, onVote, hasVoted }: OptionListProps) {
+  const totalVotes = options.reduce((sum, opt) => sum + opt.votes, 0);
+
+  const sortedOptions = [...options].sort((a, b) => b.votes - a.votes);
+
+  return (
+    <div className="space-y-3">
+      {sortedOptions.length === 0 ? (
+        <div className="text-center py-8 text-white/60">
+          No options yet. Add one to get started!
+        </div>
+      ) : (
+        sortedOptions.map((option) => {
+          const percentage = totalVotes > 0 ? (option.votes / totalVotes) * 100 : 0;
+          const userHasVoted = hasVoted ? hasVoted(option) : false;
+          
+          return (
+            <div
+              key={option.id}
+              className={`bg-white/10 backdrop-blur-sm rounded-lg p-4 border transition-all duration-200 ${
+                userHasVoted 
+                  ? 'border-green-400/50 bg-green-400/10' 
+                  : 'border-white/20 hover:border-white/30'
+              }`}
+            >
+              <div className="flex items-center justify-between mb-2">
+                <span className="text-white font-medium text-lg">
+                  {option.text}
+                  {userHasVoted && <span className="ml-2 text-green-400 text-sm">✓ Voted</span>}
+                </span>
+                <VoteButton optionId={option.id} votes={option.votes} onVote={onVote} disabled={userHasVoted} />
+              </div>
+              
+              <div className="w-full bg-white/10 rounded-full h-2 overflow-hidden">
+                <div
+                  className="bg-gradient-to-r from-green-400 to-blue-500 h-full transition-all duration-500 ease-out"
+                  style={{ width: `${percentage}%` }}
+                />
+              </div>
+              
+              <div className="mt-2 flex justify-between text-xs text-white/60">
+                <span>by {option.createdBy}</span>
+                <span>{percentage.toFixed(1)}%</span>
+              </div>
+            </div>
+          );
+        })
+      )}
+    </div>
+  );
+}
--- a/frontend/src/components/PollCard.tsx
+++ b/frontend/src/components/PollCard.tsx
@@ -0,0 +1,50 @@
+import { Poll } from '../types/poll.types';
+import { AddOption } from './AddOption';
+import { OptionList } from './OptionList';
+import { User, Clock } from 'lucide-react';
+
+interface PollCardProps {
+  poll: Poll;
+  onAddOption: (pollId: string, text: string) => void;
+  onVote: (pollId: string, optionId: string) => void;
+  hasVoted: (option: any) => boolean;
+}
+
+export function PollCard({ poll, onAddOption, onVote, hasVoted }: PollCardProps) {
+  const handleAddOption = (text: string) => {
+    onAddOption(poll.id, text);
+  };
+
+  const handleVote = (optionId: string) => {
+    onVote(poll.id, optionId);
+  };
+
+  const formatTime = (timestamp: number) => {
+    const date = new Date(timestamp);
+    return date.toLocaleString();
+  };
+
+  return (
+    <div className="bg-white/10 backdrop-blur-lg rounded-2xl shadow-2xl p-8 border border-white/20 mb-6">
+      <div className="mb-6">
+        <h2 className="text-3xl font-bold text-white mb-3">{poll.question}</h2>
+        <div className="flex items-center gap-4 text-white/60 text-sm">
+          <div className="flex items-center gap-1">
+            <User className="w-4 h-4" />
+            <span>{poll.createdBy}</span>
+          </div>
+          <div className="flex items-center gap-1">
+            <Clock className="w-4 h-4" />
+            <span>{formatTime(poll.timestamp)}</span>
+          </div>
+        </div>
+      </div>
+
+      <div className="mb-6">
+        <AddOption onAdd={handleAddOption} />
+      </div>
+
+      <OptionList options={poll.options} onVote={handleVote} hasVoted={hasVoted} />
+    </div>
+  );
+}
--- a/frontend/src/components/PollView.tsx
+++ b/frontend/src/components/PollView.tsx
@@ -0,0 +1,57 @@
+import { RefreshCw } from 'lucide-react';
+import { usePoll } from '../hooks/usePoll';
+import { CreatePoll } from './CreatePoll';
+import { PollCard } from './PollCard';
+import { ConnectionStatus } from './ConnectionStatus';
+
+export function PollView() {
+  const { polls, createPoll, addOption, vote, hasVoted, isConnected, wsProvider, webrtcProvider } = usePoll();
+
+  return (
+    <div className="min-h-screen p-4 py-8">
+      <div className="max-w-4xl mx-auto">
+        <div className="mb-8 flex items-center justify-between">
+          <div>
+            <h1 className="text-4xl font-bold text-white mb-2">P2P Polling App</h1>
+            <p className="text-white/70">Create polls, add answers, and vote in real-time</p>
+          </div>
+          <ConnectionStatus 
+            isConnected={isConnected} 
+            wsProvider={wsProvider}
+            webrtcProvider={webrtcProvider}
+          />
+        </div>
+
+        <CreatePoll onCreate={createPoll} />
+
+        {polls.length === 0 ? (
+          <div className="bg-white/10 backdrop-blur-lg rounded-2xl shadow-2xl p-12 border border-white/20 text-center">
+            <p className="text-white/60 text-lg mb-2">No polls yet!</p>
+            <p className="text-white/40">Create the first poll to get started.</p>
+          </div>
+        ) : (
+          <div className="space-y-6">
+            {polls.map((poll) => (
+              <PollCard
+                key={poll.id}
+                poll={poll}
+                onAddOption={addOption}
+                onVote={vote}
+                hasVoted={hasVoted}
+              />
+            ))}
+          </div>
+        )}
+
+        <div className="mt-8 text-center text-white/50 text-sm">
+          <p>QUIC P2P Experiment !</p>
+          <p className="flex items-center justify-center gap-2 mt-1">
+            <RefreshCw className="w-4 h-4" />
+            Real-time P2P synchronization with Yjs
+          </p>
+          <p className="mt-1">Open multiple tabs to see live updates!</p>
+        </div>
+      </div>
+    </div>
+  );
+}
--- a/frontend/src/components/VoteButton.tsx
+++ b/frontend/src/components/VoteButton.tsx
@@ -0,0 +1,25 @@
+import { ThumbsUp } from 'lucide-react';
+
+interface VoteButtonProps {
+  optionId: string;
+  votes: number;
+  onVote: (optionId: string) => void;
+  disabled?: boolean;
+}
+
+export function VoteButton({ optionId, votes, onVote, disabled = false }: VoteButtonProps) {
+  return (
+    <button
+      onClick={() => !disabled && onVote(optionId)}
+      disabled={disabled}
+      className={`flex items-center gap-2 px-4 py-2 rounded-lg transition-all duration-200 text-white font-medium ${
+        disabled 
+          ? 'bg-white/10 cursor-not-allowed opacity-60' 
+          : 'bg-white/20 hover:bg-white/30'
+      }`}
+    >
+      <ThumbsUp className="w-4 h-4" />
+      <span>{votes}</span>
+    </button>
+  );
+}
--- a/frontend/src/hooks/usePoll.ts
+++ b/frontend/src/hooks/usePoll.ts
@@ -0,0 +1,37 @@
+import { useCallback } from 'react';
+import { pollManager } from '../lib/poll-manager';
+import { useYjsSync } from './useYjsSync';
+
+export function usePoll() {
+  const { polls, isConnected, wsProvider, webrtcProvider } = useYjsSync();
+
+  const createPoll = useCallback((question: string) => {
+    return pollManager.createPoll(question);
+  }, []);
+
+  const addOption = useCallback((pollId: string, text: string) => {
+    pollManager.addOption(pollId, text);
+  }, []);
+
+  const vote = useCallback((pollId: string, optionId: string) => {
+    pollManager.vote(pollId, optionId);
+  }, []);
+
+  const hasVoted = useCallback((option: any) => {
+    return pollManager.hasVoted(option);
+  }, []);
+
+  const userId = pollManager.getUserId();
+
+  return {
+    polls,
+    createPoll,
+    addOption,
+    vote,
+    hasVoted,
+    userId,
+    isConnected,
+    wsProvider,
+    webrtcProvider
+  };
+}
--- a/frontend/src/hooks/useYjsSync.ts
+++ b/frontend/src/hooks/useYjsSync.ts
@@ -0,0 +1,50 @@
+import { useEffect, useState } from 'react';
+import { Poll } from '../types/poll.types';
+import { 
+  initializeProviders, 
+  destroyProviders, 
+  yPolls,
+  wsProvider,
+  webrtcProvider 
+} from '../lib/yjs-setup';
+
+export function useYjsSync() {
+  const [polls, setPolls] = useState<Poll[]>([]);
+  const [isConnected, setIsConnected] = useState(false);
+
+  useEffect(() => {
+    console.log('[SYNC] Initializing Yjs sync hook');
+    const { wsProvider: ws } = initializeProviders();
+
+    const updatePolls = () => {
+      const currentPolls = Array.from(yPolls.values());
+      console.log('[SYNC] Polls updated, count:', currentPolls.length);
+      setPolls(currentPolls);
+    };
+
+    yPolls.observe(updatePolls);
+    updatePolls();
+
+    const handleStatus = (event: { status: string }) => {
+      console.log('[SYNC] WebSocket status event:', event.status);
+      const connected = event.status === 'connected';
+      setIsConnected(connected);
+      console.log('[SYNC] Connection state set to:', connected);
+    };
+
+    ws?.on('status', handleStatus);
+
+    return () => {
+      yPolls.unobserve(updatePolls);
+      ws?.off('status', handleStatus);
+      destroyProviders();
+    };
+  }, []);
+
+  return { 
+    polls, 
+    isConnected,
+    wsProvider,
+    webrtcProvider
+  };
+}
--- a/frontend/src/lib/poll-manager.ts
+++ b/frontend/src/lib/poll-manager.ts
@@ -0,0 +1,43 @@
+import { PollOption } from '../types/poll.types';
+import { createPoll as yjsCreatePoll, addOption as yjsAddOption, voteForOption as yjsVoteForOption } from './yjs-setup';
+
+export class PollManager {
+  private userId: string;
+
+  constructor() {
+    this.userId = this.generateUserId();
+  }
+
+  private generateUserId(): string {
+    const stored = localStorage.getItem('p2p-poll-user-id');
+    if (stored) return stored;
+    
+    const newId = 'user-' + Math.random().toString(36).substr(2, 9);
+    localStorage.setItem('p2p-poll-user-id', newId);
+    return newId;
+  }
+
+  getUserId(): string {
+    return this.userId;
+  }
+
+  createPoll(question: string): string {
+    if (!question.trim()) return '';
+    return yjsCreatePoll(question.trim(), this.userId);
+  }
+
+  addOption(pollId: string, text: string): void {
+    if (!text.trim()) return;
+    yjsAddOption(pollId, text.trim(), this.userId);
+  }
+
+  vote(pollId: string, optionId: string): void {
+    yjsVoteForOption(pollId, optionId, this.userId);
+  }
+
+  hasVoted(option: PollOption): boolean {
+    return option.votedBy.includes(this.userId);
+  }
+}
+
+export const pollManager = new PollManager();
--- a/frontend/src/lib/yjs-setup.ts
+++ b/frontend/src/lib/yjs-setup.ts
@@ -0,0 +1,287 @@
+import * as Y from 'yjs';
+import { WebsocketProvider } from 'y-websocket';
+import { WebrtcProvider } from 'y-webrtc';
+import { Poll, PollOption } from '../types/poll.types';
+
+const WS_URL = import.meta.env.VITE_WS_URL || 'ws://localhost:5000';
+const ROOM_NAME = 'default-poll';
+
+function getSignalingUrl(wsUrl: string): string {
+  try {
+    const url = new URL(wsUrl);
+    const protocol = url.protocol === 'ws:' ? 'ws' : 'wss';
+    return `${protocol}://${url.host}/signal`;
+  } catch (error) {
+    console.error('Invalid WebSocket URL:', wsUrl, error);
+    return wsUrl + '/signal';
+  }
+}
+
+export const ydoc = new Y.Doc();
+
+export const yPolls = ydoc.getMap<Poll>('polls');
+
+export let wsProvider: WebsocketProvider | null = null;
+export let webrtcProvider: WebrtcProvider | null = null;
+
+let wsReconnectAttempts = 0;
+let webrtcReconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 5;
+const BASE_RECONNECT_DELAY = 1000;
+
+interface ConnectionMetrics {
+  rtt: number;
+  bandwidth: number;
+  packetLoss: number;
+  lastUpdated: number;
+}
+
+const connectionMetrics: ConnectionMetrics = {
+  rtt: 0,
+  bandwidth: 0,
+  packetLoss: 0,
+  lastUpdated: Date.now()
+};
+
+function getReconnectDelay(attempts: number): number {
+  return Math.min(BASE_RECONNECT_DELAY * Math.pow(2, attempts), 30000);
+}
+
+export function getConnectionMetrics(): ConnectionMetrics {
+  return { ...connectionMetrics };
+}
+
+export function initializeProviders() {
+  console.log('[INIT] Initializing providers with WS_URL:', WS_URL);
+  console.log('[INIT] Connecting to WebSocket:', WS_URL + '/yjs');
+  console.log('[INIT] Room name:', ROOM_NAME);
+  console.log('[INIT] Signaling URL:', getSignalingUrl(WS_URL));
+
+  wsProvider = new WebsocketProvider(
+    WS_URL + '/yjs',
+    ROOM_NAME,
+    ydoc,
+    { connect: true }
+  );
+
+  webrtcProvider = new WebrtcProvider(
+    ROOM_NAME,
+    ydoc,
+    { 
+      signaling: [getSignalingUrl(WS_URL)],
+      password: null,
+      awareness: wsProvider.awareness,
+      maxConns: 20,
+      filterBcConns: true,
+      peerOpts: {}
+    }
+  );
+
+  wsProvider.on('status', (event: { status: string }) => {
+    console.log('[WS] WebSocket status changed:', event.status);
+    
+    if (event.status === 'connected') {
+      wsReconnectAttempts = 0;
+      console.log('[WS] Successfully connected to WebSocket');
+    } else if (event.status === 'disconnected') {
+      console.log('[WS] WebSocket disconnected');
+      if (wsReconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        const delay = getReconnectDelay(wsReconnectAttempts);
+        console.log(`[WS] Reconnecting in ${delay}ms (attempt ${wsReconnectAttempts + 1})`);
+        setTimeout(() => {
+          wsReconnectAttempts++;
+          try {
+            wsProvider?.connect();
+          } catch (error) {
+            console.error('[WS] Failed to reconnect:', error);
+          }
+        }, delay);
+      } else {
+        console.error('[WS] Max reconnection attempts reached');
+      }
+    }
+  });
+
+  wsProvider.on('connection-error', (error: any) => {
+    console.error('[WS] Connection error:', error);
+  });
+
+  webrtcProvider.on('synced', (synced: boolean) => {
+    console.log('[WEBRTC] Synced:', synced);
+    if (synced) {
+      webrtcReconnectAttempts = 0;
+    }
+  });
+
+  webrtcProvider.on('peers', (peers: any) => {
+    console.log('[WEBRTC] Peers changed:', peers.size, 'peers');
+    if (peers.size === 0 && webrtcReconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+      const delay = getReconnectDelay(webrtcReconnectAttempts);
+      console.log(`[WEBRTC] No peers, reconnecting in ${delay}ms (attempt ${webrtcReconnectAttempts + 1})`);
+      setTimeout(() => {
+        webrtcReconnectAttempts++;
+        try {
+          webrtcProvider?.connect();
+        } catch (error) {
+          console.error('[WEBRTC] Failed to reconnect:', error);
+        }
+      }, delay);
+    } else if (peers.size > 0) {
+      webrtcReconnectAttempts = 0;
+      console.log('[WEBRTC] Connected to', peers.size, 'peers');
+    }
+  });
+
+  // Periodically collect WebRTC stats
+  const statsInterval = setInterval(async () => {
+    if (webrtcProvider && webrtcProvider.room) {
+      let totalRtt = 0;
+      let totalBandwidth = 0;
+      let peerCount = 0;
+
+      // Access peers through the room's internal structure
+      const room = webrtcProvider.room as any;
+      if (room.peers) {
+        for (const peer of room.peers.values()) {
+          try {
+            if (peer.peerConnection) {
+              const stats = await peer.peerConnection.getStats();
+              stats.forEach((report: any) => {
+                if (report.type === 'remote-inbound-rtp' || report.type === 'inbound-rtp') {
+                  totalRtt += report.roundTripTime || 0;
+                }
+                if (report.type === 'outbound-rtp') {
+                  totalBandwidth += report.bytesSent || 0;
+                }
+              });
+              peerCount++;
+            }
+          } catch (error) {
+            console.error('Failed to get WebRTC stats:', error);
+          }
+        }
+      }
+
+      if (peerCount > 0) {
+        connectionMetrics.rtt = totalRtt / peerCount;
+        connectionMetrics.bandwidth = totalBandwidth;
+        connectionMetrics.packetLoss = 0; // Would need more complex calculation
+        connectionMetrics.lastUpdated = Date.now();
+      }
+    }
+  }, 5000);
+
+  // Cleanup stats interval on destroy
+  const originalDestroy = webrtcProvider.destroy;
+  webrtcProvider.destroy = function() {
+    clearInterval(statsInterval);
+    originalDestroy.call(this);
+  };
+
+  return { wsProvider, webrtcProvider };
+}
+
+export function destroyProviders() {
+  wsProvider?.destroy();
+  webrtcProvider?.destroy();
+}
+
+export function createPoll(question: string, createdBy: string): string {
+  const pollId = crypto.randomUUID();
+  const poll: Poll = {
+    id: pollId,
+    question,
+    createdBy,
+    timestamp: Date.now(),
+    options: []
+  };
+  
+  yPolls.set(pollId, poll);
+  return pollId;
+}
+
+export function addOption(pollId: string, text: string, createdBy: string): void {
+  try {
+    ydoc.transact(() => {
+      const poll = yPolls.get(pollId);
+      
+      if (!poll) {
+        console.error(`Poll not found: ${pollId}`);
+        throw new Error('Poll not found');
+      }
+      
+      const option: PollOption = {
+        id: crypto.randomUUID(),
+        text,
+        votes: 0,
+        votedBy: [],
+        createdBy,
+        timestamp: Date.now()
+      };
+      
+      const updatedPoll = {
+        ...poll,
+        options: [...poll.options, option]
+      };
+      
+      yPolls.set(pollId, updatedPoll);
+    });
+  } catch (error) {
+    console.error('Failed to add option:', error);
+    throw error;
+  }
+}
+
+export function voteForOption(pollId: string, optionId: string, userId: string): void {
+  try {
+    ydoc.transact(() => {
+      const poll = yPolls.get(pollId);
+      
+      if (!poll) {
+        console.error(`Poll not found: ${pollId}`);
+        throw new Error('Poll not found');
+      }
+      
+      const optionIndex = poll.options.findIndex(opt => opt.id === optionId);
+      
+      if (optionIndex === -1) {
+        console.error(`Option not found: ${optionId}`);
+        throw new Error('Option not found');
+      }
+      
+      const option = poll.options[optionIndex];
+      
+      if (option.votedBy.includes(userId)) {
+        console.log(`User ${userId} already voted for option ${optionId}`);
+        return;
+      }
+      
+      const updatedOption = {
+        ...option,
+        votes: option.votes + 1,
+        votedBy: [...option.votedBy, userId]
+      };
+      
+      const updatedOptions = [...poll.options];
+      updatedOptions[optionIndex] = updatedOption;
+      
+      const updatedPoll = {
+        ...poll,
+        options: updatedOptions
+      };
+      
+      yPolls.set(pollId, updatedPoll);
+    });
+  } catch (error) {
+    console.error('Failed to vote for option:', error);
+    throw error;
+  }
+}
+
+export function getPolls(): Poll[] {
+  return Array.from(yPolls.values());
+}
+
+export function getPoll(pollId: string): Poll | undefined {
+  return yPolls.get(pollId);
+}
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -0,0 +1,9 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
--- a/frontend/src/styles/index.css
+++ b/frontend/src/styles/index.css
@@ -0,0 +1,17 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+#root {
+  min-height: 100vh;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+}
--- a/frontend/src/types/poll.types.ts
+++ b/frontend/src/types/poll.types.ts
@@ -0,0 +1,22 @@
+export interface PollOption {
+  id: string;
+  text: string;
+  votes: number;
+  votedBy: string[];
+  createdBy: string;
+  timestamp: number;
+}
+
+export interface Poll {
+  id: string;
+  question: string;
+  createdBy: string;
+  timestamp: number;
+  options: PollOption[];
+}
+
+export interface ConnectionStatus {
+  websocket: boolean;
+  webrtc: boolean;
+  peers: number;
+}
--- a/frontend/tailwind.config.js
+++ b/frontend/tailwind.config.js
@@ -0,0 +1,11 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
--- a/frontend/tsconfig.json
+++ b/frontend/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}
--- a/frontend/tsconfig.node.json
+++ b/frontend/tsconfig.node.json
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    host: true
+  }
+})
--- a/index.html
+++ b/index.html
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>P2P Polling App</title>
-    <link rel="stylesheet" href="css/styles.css">
-    <script src="https://unpkg.com/peerjs@1.5.2/dist/peerjs.min.js"></script>
-</head>
-<body>
-    <div class="container">
-        <header>
-            <h1>P2P Polling App</h1>
-            <div class="connection-status">
-                <span id="peer-id">Loading...</span>
-                <span id="connection-indicator" class="status-disconnected">●</span>
-            </div>
-        </header>
-
-        <div class="main-content">
-            <!-- Sidebar -->
-            <aside class="sidebar">
-                <div class="sidebar-section">
-                    <h3>Available Polls</h3>
-                    <div class="sidebar-hint">
-                        <p class="hint-text">Click a poll to view and vote</p>
-                    </div>
-                    <div id="polls-list" class="polls-list">
-                        <p class="no-polls">No polls created yet</p>
-                    </div>
-                </div>
-                
-                <div class="sidebar-section">
-                    <h3>Connected Peers</h3>
-                    <div class="peers-info">
-                        <div class="peers-status">
-                            <span>Count: <span id="peer-count">0</span></span>
-                            <span id="connection-status-text" class="status-text">Disconnected</span>
-                        </div>
-                        <ul id="peers" class="peers-sidebar"></ul>
-                    </div>
-                </div>
-            </aside>
-
-            <main>
-                <!-- Connection Setup -->
-                <section id="connection-section" class="section">
-                    <h2>Connect to Peer</h2>
-                    <div class="connection-info">
-                        <p><strong>Host:</strong> Share your Peer ID below with others</p>
-                        <p><strong>Joiner:</strong> Enter the host's Peer ID to connect</p>
-                    </div>
-                    <div class="connection-controls">
-                        <input type="text" id="room-id" placeholder="Enter host's Peer ID to connect">
-                        <button id="join-btn">Connect to Host / Create New Poll</button>
-                        <button id="copy-id-btn">Copy Your Peer ID</button>
-                    </div>
-                </section>
-
-                <!-- Poll Creation -->
-                <section id="poll-creation" class="section hidden">
-                    <h2>Create Poll</h2>
-                    <div class="poll-form">
-                        <input type="text" id="poll-question" placeholder="Enter your poll question">
-                        <div id="options-container">
-                            <div class="option-input">
-                                <input type="text" class="option-text" placeholder="Option 1">
-                                <button class="remove-option-btn hidden">Remove</button>
-                            </div>
-                            <div class="option-input">
-                                <input type="text" class="option-text" placeholder="Option 2">
-                                <button class="remove-option-btn hidden">Remove</button>
-                            </div>
-                        </div>
-                        <button id="add-option-btn">+ Add Option</button>
-                        <button id="create-poll-btn">Create Poll</button>
-                    </div>
-                </section>
-
-                <!-- Active Poll -->
-                <section id="active-poll" class="section hidden">
-                    <div class="poll-header">
-                        <h2 id="poll-question-display"></h2>
-                        <button id="add-poll-option-btn" class="small-btn">+ Add Option</button>
-                    </div>
-                    
-                    <div class="vote-hint">
-                        <p class="hint-text">Click any option to vote. Click your voted option again to remove your vote.</p>
-                    </div>
-                    
-                    <div id="poll-options" class="options-list"></div>
-                    
-                    <div class="poll-actions">
-                        <button id="reset-poll-btn">Reset Poll</button>
-                        <button id="new-poll-btn" class="small-btn">New Poll</button>
-                    </div>
-                </section>
-            </main>
-        </div>
-
-        <!-- Loading Overlay -->
-        <div id="loading-overlay" class="overlay hidden">
-            <div class="loading-spinner"></div>
-            <p>Connecting...</p>
-        </div>
-
-        <!-- Notification Toast -->
-        <div id="notification" class="notification hidden"></div>
-
-        <!-- Add Option Modal -->
-        <div id="add-option-modal" class="modal hidden">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h3>Add New Option</h3>
-                    <button class="modal-close" id="close-modal-btn">&times;</button>
-                </div>
-                <div class="modal-body">
-                    <input type="text" id="new-option-input" placeholder="Enter new option text">
-                </div>
-                <div class="modal-footer">
-                    <button id="cancel-modal-btn" class="btn-secondary">Cancel</button>
-                    <button id="save-option-btn" class="btn-primary">Add Option</button>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <script src="js/peer-manager.js"></script>
-    <script src="js/poll-manager.js"></script>
-    <script src="js/ui-controller.js"></script>
-    <script src="js/app.js"></script>
-</body>
-</html>
--- a/js/app.js
+++ b/js/app.js
@@ -1,210 +0,0 @@
-// Main application entry point
-class P2PPollApp {
-    constructor() {
-        this.peerManager = null;
-        this.pollManager = null;
-        this.uiController = null;
-        this.isInitialized = false;
-    }
-
-    async initialize() {
-        try {
-            // Initialize peer manager
-            this.peerManager = new PeerManager();
-            this.pollManager = new PollManager(this.peerManager);
-            this.uiController = new UIController(this.peerManager, this.pollManager);
-
-            // Set up event handlers
-            this.setupEventHandlers();
-
-            // Initialize peer connection
-            await this.peerManager.initialize();
-
-            // Load saved data
-            this.pollManager.loadFromLocalStorage();
-
-            // If there are saved polls, update the sidebar
-            const savedPolls = this.pollManager.getAvailablePolls();
-            if (savedPolls.length > 0) {
-                this.uiController.updatePollsList(savedPolls);
-            }
-
-         
-            this.isInitialized = true;
-            console.log('P2P Poll App initialized successfully');
-
-        } catch (error) {
-            console.error('Failed to initialize app:', error);
-            this.uiController?.showNotification('Failed to initialize app: ' + error.message, 'error');
-        }
-    }
-
-    setupEventHandlers() {
-        // Peer manager events
-        this.peerManager.onConnectionStatusChange = (status, peerId) => {
-            this.uiController.updatePeerId(peerId);
-            
-            if (status === 'connected') {
-                this.uiController.showNotification('Connected to P2P network', 'success');
-            } else if (status === 'disconnected') {
-                this.uiController.showNotification('Disconnected from P2P network', 'error');
-            }
-        };
-
-        this.peerManager.onPeerConnected = (peerId) => {
-            this.uiController.showNotification(`Peer ${peerId} connected`, 'success');
-            
-            // If we're the host and have polls, send them to the new peer
-            if (this.peerManager.isHost) {
-                const availablePolls = this.pollManager.getAvailablePolls();
-                if (availablePolls.length > 0) {
-                    availablePolls.forEach(poll => {
-                        this.peerManager.sendMessage(peerId, {
-                            type: 'poll_update',
-                            poll: poll,
-                            senderId: this.peerManager.getPeerId()
-                        });
-                    });
-                    
-                    // Also send current poll if there is one
-                    const currentPoll = this.pollManager.getCurrentPoll();
-                    if (currentPoll) {
-                        this.peerManager.sendMessage(peerId, {
-                            type: 'current_poll',
-                            poll: currentPoll,
-                            senderId: this.peerManager.getPeerId()
-                        });
-                    }
-                }
-            } else {
-                this.peerManager.sendMessage(peerId, {
-                    type: 'sync_request',
-                    senderId: this.peerManager.getPeerId()
-                });
-            }
-        };
-
-        this.peerManager.onPeerDisconnected = (peerId) => {
-            this.uiController.showNotification(`Peer ${peerId} disconnected`, 'info');
-        };
-
-        this.peerManager.onMessageReceived = (message, senderId) => {
-            this.handleMessage(message, senderId);
-        };
-
-        // Poll manager events
-        this.pollManager.onPollCreated = (poll) => {
-            this.uiController.renderPoll(poll);
-        };
-
-        this.pollManager.onPollUpdated = (poll) => {
-            this.uiController.renderPoll(poll);
-        };
-
-        this.pollManager.onPollSelected = (poll) => {
-            if (poll) {
-                this.uiController.renderPoll(poll);
-                this.uiController.showActivePoll();
-            } else {
-                this.uiController.showPollCreation();
-            }
-        };
-
-        this.pollManager.onPollsListUpdated = (polls) => {
-            this.uiController.updatePollsList(polls);
-        };
-    }
-
-    handleMessage(message, senderId) {
-        console.log('Processing message:', message, 'from:', senderId);
-
-        switch (message.type) {
-            case 'poll_update':
-                this.pollManager.syncPoll(message.poll);
-                break;
-
-            case 'current_poll':
-                this.pollManager.syncPoll(message.poll);
-                if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === message.poll.id) {
-                    this.uiController.renderPoll(message.poll);
-                    this.uiController.showActivePoll();
-                }
-                break;
-
-            case 'vote':
-                this.pollManager.handleVoteMessage(message.optionId, message.voterId);
-                break;
-
-            case 'unvote':
-                this.pollManager.handleUnvoteMessage(message.voterId);
-                break;
-
-            case 'poll_reset':
-                this.pollManager.handlePollReset();
-                break;
-
-            case 'sync_request':
-                    const currentPoll = this.pollManager.getCurrentPoll();
-                if (currentPoll) {
-                    this.peerManager.sendMessage(senderId, {
-                        type: 'current_poll',
-                        poll: currentPoll,
-                        senderId: this.peerManager.getPeerId()
-                    });
-                }
-                
-                const availablePolls = this.pollManager.getAvailablePolls();
-                availablePolls.forEach(poll => {
-                    this.peerManager.sendMessage(senderId, {
-                        type: 'poll_update',
-                        poll: poll,
-                        senderId: this.peerManager.getPeerId()
-                    });
-                });
-                break;
-
-            default:
-                console.warn('Unknown message type:', message.type);
-        }
-    }
-
-    destroy() {
-        if (this.peerManager) {
-            this.peerManager.destroy();
-        }
-    }
-}
-
-document.addEventListener('DOMContentLoaded', async () => {
-    const app = new P2PPollApp();
-    
-    try {
-        await app.initialize();
-    } catch (error) {
-        console.error('App initialization failed:', error);
-        
-        // Show error message to user
-        const errorDiv = document.createElement('div');
-        errorDiv.className = 'notification error';
-        errorDiv.textContent = 'Failed to initialize app. Please refresh the page.';
-        errorDiv.style.position = 'fixed';
-        errorDiv.style.top = '20px';
-        errorDiv.style.right = '20px';
-        errorDiv.style.zIndex = '1001';
-        document.body.appendChild(errorDiv);
-    }
-
-    // Cleanup on page unload
-    window.addEventListener('beforeunload', () => {
-        app.destroy();
-    });
-});
-
-// Handle page visibility changes
-document.addEventListener('visibilitychange', () => {
-    if (document.hidden) {
-        console.log('Page hidden - connection may become unstable');
-    } else {
-        console.log('Page visible - checking connection status');
-    }
-});
--- a/js/peer-manager.js
+++ b/js/peer-manager.js
@@ -1,233 +0,0 @@
-class PeerManager {
-    constructor() {
-        this.peer = null;
-        this.connections = new Map();
-        this.roomId = null;
-        this.isHost = false;
-        this.onPeerConnected = null;
-        this.onPeerDisconnected = null;
-        this.onMessageReceived = null;
-        this.onConnectionStatusChange = null;
-    }
-
-    async initialize() {
-        try {
-            this.peer = new Peer({
-                debug: 2,
-                config: {
-                    iceServers: [
-                        { urls: 'stun:stun.l.google.com:19302' },
-                        { urls: 'stun:stun1.l.google.com:19302' }
-                    ]
-                }
-            });
-
-            this.peer.on('open', (id) => {
-                console.log('My peer ID is:', id);
-                this.updateConnectionStatus('connected');
-                this.updatePeersList(); 
-                if (this.onConnectionStatusChange) {
-                    this.onConnectionStatusChange('connected', id);
-                }
-            });
-
-            this.peer.on('connection', (conn) => {
-                this.handleIncomingConnection(conn);
-            });
-
-            this.peer.on('disconnected', () => {
-                this.updateConnectionStatus('disconnected');
-                this.updatePeersList(); 
-            });
-
-            this.peer.on('error', (err) => {
-                console.error('Peer error:', err);
-                this.updateConnectionStatus('error');
-            });
-
-        } catch (error) {
-            console.error('Failed to initialize peer:', error);
-            throw error;
-        }
-    }
-
-    async createRoom() {
-        if (!this.peer) {
-            throw new Error('Peer not initialized');
-        }
-
-        this.roomId = this.generateRoomId();
-        this.isHost = true;
-        
-        console.log('Created room:', this.roomId);
-        return this.roomId;
-    }
-
-    async joinRoom(roomId) {
-        if (!this.peer) {
-            throw new Error('Peer not initialized');
-        }
-
-        this.roomId = roomId;
-        this.isHost = false;
-
-        console.log('Attempting to join room:', roomId);
-        
-
-        try {
-            const conn = this.peer.connect(roomId);
-            await this.setupConnection(conn);
-            console.log('Successfully joined room');
-            return true;
-        } catch (error) {
-            console.error('Failed to join room:', error);
-            throw new Error('Could not connect to host. Make sure the host is online and you have the correct peer ID.');
-        }
-    }
-
-    handleIncomingConnection(conn) {
-        this.setupConnection(conn);
-    }
-
-    async setupConnection(conn) {
-        return new Promise((resolve, reject) => {
-            conn.on('open', () => {
-                console.log('Connected to:', conn.peer);
-                this.connections.set(conn.peer, conn);
-                this.updatePeersList();
-
-                if (this.isHost) {
-                    if (this.onPeerConnected) {
-                        this.onPeerConnected(conn.peer);
-                    }
-                } else {
-                    if (this.onPeerConnected) {
-                        this.onPeerConnected(conn.peer);
-                    }
-                }
-
-                resolve(conn);
-            });
-
-            conn.on('data', (data) => {
-                this.handleMessage(data, conn.peer);
-            });
-
-            conn.on('close', () => {
-                console.log('Connection closed:', conn.peer);
-                this.connections.delete(conn.peer);
-                this.updatePeersList();
-                
-                if (this.onPeerDisconnected) {
-                    this.onPeerDisconnected(conn.peer);
-                }
-            });
-
-            conn.on('error', (err) => {
-                console.error('Connection error:', err);
-                reject(err);
-            });
-        });
-    }
-
-    handleMessage(data, senderId) {
-        console.log('Received message:', data, 'from:', senderId);
-        
-        if (this.onMessageReceived) {
-            this.onMessageReceived(data, senderId);
-        }
-    }
-
-    sendMessage(peerId, message) {
-        const conn = this.connections.get(peerId);
-        if (conn && conn.open) {
-            conn.send(message);
-            return true;
-        }
-        return false;
-    }
-
-    broadcastMessage(message) {
-        let sentCount = 0;
-        this.connections.forEach((conn, peerId) => {
-            if (conn.open) {
-                conn.send(message);
-                sentCount++;
-            }
-        });
-        return sentCount;
-    }
-
-    getPeerId() {
-        return this.peer ? this.peer.id : null;
-    }
-
-    getRoomId() {
-        return this.roomId;
-    }
-
-    getConnectedPeers() {
-        return Array.from(this.connections.keys());
-    }
-
-    getPeerCount() {
-        return this.connections.size;
-    }
-
-    isConnected() {
-        return this.peer && this.peer.disconnected !== true;
-    }
-
-    generateRoomId() {
-        return Math.random().toString(36).substr(2, 9).toUpperCase();
-    }
-
-    updateConnectionStatus(status) {
-        const indicator = document.getElementById('connection-indicator');
-        const statusText = document.getElementById('connection-status-text');
-        
-        if (indicator) {
-            indicator.className = `status-${status}`;
-        }
-        
-        if (statusText) {
-            statusText.textContent = status.charAt(0).toUpperCase() + status.slice(1);
-            statusText.className = `status-text ${status}`;
-        }
-    }
-
-    updatePeersList() {
-        const peersList = document.getElementById('peers');
-        const peerCount = document.getElementById('peer-count');
-        
-        if (peersList && peerCount) {
-            peerCount.textContent = this.getPeerCount();
-            peersList.innerHTML = '';
-            
-            if (this.getPeerCount() === 0) {
-                const li = document.createElement('li');
-                li.textContent = 'No connected peers';
-                li.style.fontStyle = 'italic';
-                li.style.color = '#9ca3af';
-                peersList.appendChild(li);
-            } else {
-                this.getConnectedPeers().forEach(peerId => {
-                    const li = document.createElement('li');
-                    li.textContent = `${peerId} ${peerId === this.peer.id ? '(You)' : ''}`;
-                    li.style.fontWeight = peerId === this.peer.id ? 'bold' : 'normal';
-                    li.style.color = peerId === this.peer.id ? '#667eea' : '#6b7280';
-                    peersList.appendChild(li);
-                });
-            }
-        }
-    }
-
-    destroy() {
-        if (this.peer) {
-            this.connections.forEach(conn => conn.close());
-            this.peer.destroy();
-            this.peer = null;
-            this.connections.clear();
-        }
-    }
-}
--- a/js/poll-manager.js
+++ b/js/poll-manager.js
@@ -1,428 +0,0 @@
-class PollManager {
-    constructor(peerManager) {
-        this.peerManager = peerManager;
-        this.currentPoll = null;
-        this.availablePolls = new Map(); // pollId -> poll
-        this.myVotes = new Set();
-        this.onPollUpdated = null;
-        this.onPollCreated = null;
-        this.onPollSelected = null;
-        this.onPollsListUpdated = null;
-    }
-
-    createPoll(question, options) {
-        const poll = {
-            id: this.generatePollId(),
-            question: question.trim(),
-            options: options.map((text, index) => ({
-                id: `opt-${index}`,
-                text: text.trim(),
-                votes: 0,
-                voters: []
-            })),
-            createdBy: this.peerManager.getPeerId(),
-            createdAt: Date.now()
-        };
-
-        // Clear any existing votes when creating a new poll
-        this.myVotes.clear();
-        
-        this.currentPoll = poll;
-        this.availablePolls.set(poll.id, poll);
-        this.saveToLocalStorage();
-        
-        if (this.onPollCreated) {
-            this.onPollCreated(poll);
-        }
-        
-        if (this.onPollsListUpdated) {
-            this.onPollsListUpdated(Array.from(this.availablePolls.values()));
-        }
-
-        // Broadcast new poll to all peers
-        this.broadcastPollUpdate();
-        
-        return poll;
-    }
-
-    addOption(text) {
-        if (!this.currentPoll) {
-            throw new Error('No active poll');
-        }
-
-        const newOption = {
-            id: `opt-${Date.now()}`,
-            text: text.trim(),
-            votes: 0,
-            voters: []
-        };
-
-        this.currentPoll.options.push(newOption);
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-        this.broadcastPollUpdate();
-        
-        return newOption;
-    }
-
-    vote(optionId) {
-        if (!this.currentPoll) {
-            throw new Error('No active poll');
-        }
-
-        const myPeerId = this.peerManager.getPeerId();
-        
-        // Check if already voted for this option
-        if (this.myVotes.has(optionId)) {
-            return false; 
-        }
-
-        this.removePreviousVote(myPeerId);
-
-        // Add new vote
-        const option = this.currentPoll.options.find(opt => opt.id === optionId);
-        if (!option) {
-            throw new Error('Option not found');
-        }
-
-        option.votes++;
-        option.voters.push(myPeerId);
-        this.myVotes.add(optionId);
-        
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-        this.broadcastVote(optionId, myPeerId);
-        
-        return true;
-    }
-
-    removePreviousVote(peerId) {
-        if (!this.currentPoll) return;
-
-        this.currentPoll.options.forEach(option => {
-            const voterIndex = option.voters.indexOf(peerId);
-            if (voterIndex !== -1) {
-                option.votes--;
-                option.voters.splice(voterIndex, 1);
-                
-                // Remove from my votes if it's my vote
-                if (peerId === this.peerManager.getPeerId()) {
-                    this.myVotes.delete(option.id);
-                }
-            }
-        });
-    }
-
-    resetPoll() {
-        if (!this.currentPoll) {
-            throw new Error('No active poll');
-        }
-
-        this.currentPoll.options.forEach(option => {
-            option.votes = 0;
-            option.voters = [];
-        });
-
-        this.myVotes.clear();
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-        this.broadcastPollReset();
-    }
-
-    syncPoll(pollData) {
-        if (!this.availablePolls.has(pollData.id)) {
-            this.availablePolls.set(pollData.id, pollData);
-            this.saveToLocalStorage();
-            
-            if (this.onPollsListUpdated) {
-                this.onPollsListUpdated(Array.from(this.availablePolls.values()));
-            }
-        }
-        
-        if (!this.currentPoll || this.currentPoll.id === pollData.id) {
-            this.currentPoll = pollData;
-            this.availablePolls.set(pollData.id, pollData);
-            
-            this.validateMyVotes(pollData);
-            
-            this.saveToLocalStorage();
-            if (this.onPollCreated) {
-                this.onPollCreated(pollData);
-            }
-        } else if (this.currentPoll.id === pollData.id) {
-            this.mergePollData(pollData);
-            this.availablePolls.set(pollData.id, this.currentPoll);
-            
-            this.validateMyVotes(this.currentPoll);
-            
-            this.saveToLocalStorage();
-            this.notifyPollUpdated();
-        }
-    }
-
-    mergePollData(remotePoll) {
-        const localOptions = new Map(this.currentPoll.options.map(opt => [opt.id, opt]));
-        const remoteOptions = new Map(remotePoll.options.map(opt => [opt.id, opt]));
-
-        remoteOptions.forEach((remoteOpt, id) => {
-            if (!localOptions.has(id)) {
-                this.currentPoll.options.push(remoteOpt);
-                localOptions.set(id, remoteOpt);
-            }
-        });
-
-        this.currentPoll.options.forEach(localOpt => {
-            const remoteOpt = remoteOptions.get(localOpt.id);
-            if (remoteOpt) {
-                const allVoters = new Set([...localOpt.voters, ...remoteOpt.voters]);
-                localOpt.voters = Array.from(allVoters);
-                localOpt.votes = localOpt.voters.length;
-            }
-        });
-    }
-
-    handleVoteMessage(optionId, voterId) {
-        if (!this.currentPoll) return;
-
-        this.removePreviousVote(voterId);
-
-        const option = this.currentPoll.options.find(opt => opt.id === optionId);
-        if (option && !option.voters.includes(voterId)) {
-            option.votes++;
-            option.voters.push(voterId);
-            
-            // Update my votes if this is my vote
-            if (voterId === this.peerManager.getPeerId()) {
-                this.myVotes.add(optionId);
-            }
-            
-            this.saveToLocalStorage();
-            this.notifyPollUpdated();
-        }
-    }
-
-    handleUnvoteMessage(voterId) {
-        if (!this.currentPoll) return;
-
-        // Remove vote from this voter
-        this.removePreviousVote(voterId);
-        
-        // Update my votes if this is my vote
-        if (voterId === this.peerManager.getPeerId()) {
-            this.myVotes.clear();
-        }
-        
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-    }
-
-    handlePollReset() {
-        if (!this.currentPoll) return;
-
-        this.currentPoll.options.forEach(option => {
-            option.votes = 0;
-            option.voters = [];
-        });
-
-        this.myVotes.clear();
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-    }
-
-    broadcastPollUpdate() {
-        if (!this.currentPoll) return;
-
-        this.peerManager.broadcastMessage({
-            type: 'poll_update',
-            poll: this.currentPoll,
-            senderId: this.peerManager.getPeerId()
-        });
-    }
-
-    broadcastVote(optionId, voterId) {
-        this.peerManager.broadcastMessage({
-            type: 'vote',
-            optionId: optionId,
-            voterId: voterId,
-            senderId: this.peerManager.getPeerId()
-        });
-    }
-
-    broadcastPollReset() {
-        this.peerManager.broadcastMessage({
-            type: 'poll_reset',
-            senderId: this.peerManager.getPeerId()
-        });
-    }
-
-    selectPoll(pollId) {
-        const poll = this.availablePolls.get(pollId);
-        if (poll) {
-            this.currentPoll = poll;
-            
-            // Clear votes when switching to a different poll
-            // Only clear if this is a different poll than what we had voted in
-            const currentVotedOption = this.getMyVotedOption();
-            if (currentVotedOption && !poll.options.some(opt => opt.id === currentVotedOption)) {
-                this.myVotes.clear();
-            }
-            
-            this.saveToLocalStorage();
-            
-            if (this.onPollSelected) {
-                this.onPollSelected(poll);
-            }
-            
-            if (this.onPollUpdated) {
-                this.onPollUpdated(poll);
-            }
-            
-            return true;
-        }
-        return false;
-    }
-
-    createNewPoll() {
-        this.currentPoll = null;
-        // Clear current poll inputs but keep available polls
-        if (this.onPollSelected) {
-            this.onPollSelected(null);
-        }
-    }
-
-    getAvailablePolls() {
-        return Array.from(this.availablePolls.values());
-    }
-
-    unvote() {
-        if (!this.currentPoll) {
-            throw new Error('No active poll');
-        }
-
-        const myPeerId = this.peerManager.getPeerId();
-        const myVotedOption = this.getMyVotedOption();
-        
-        if (!myVotedOption) {
-            return false; // No vote to remove
-        }
-
-        // Remove vote from current option
-        this.removePreviousVote(myPeerId);
-        
-        this.saveToLocalStorage();
-        this.notifyPollUpdated();
-        this.broadcastUnvote(myPeerId);
-        
-        return true;
-    }
-
-    validateMyVotes(poll) {
-        const myPeerId = this.peerManager.getPeerId();
-        const validVotes = new Set();
-        
-        console.log('Validating votes for peer:', myPeerId);
-        console.log('Current myVotes:', Array.from(this.myVotes));
-        console.log('Poll voters:', poll.options.map(opt => ({ id: opt.id, voters: opt.voters })));
-        
-        // Check each vote in myVotes to see if it's actually mine
-        this.myVotes.forEach(optionId => {
-            const option = poll.options.find(opt => opt.id === optionId);
-            if (option && option.voters.includes(myPeerId)) {
-                // This vote is actually mine
-                validVotes.add(optionId);
-                console.log(`Vote ${optionId} is valid for peer ${myPeerId}`);
-            } else {
-                console.log(`Vote ${optionId} is NOT valid for peer ${myPeerId}`);
-            }
-        });
-        
-        // Replace myVotes with only the valid votes
-        this.myVotes = validVotes;
-        console.log('Final valid votes:', Array.from(this.myVotes));
-    }
-
-    getCurrentPoll() {
-        return this.currentPoll;
-    }
-
-    broadcastUnvote(peerId) {
-        this.peerManager.broadcastMessage({
-            type: 'unvote',
-            voterId: peerId,
-            senderId: this.peerManager.getPeerId()
-        });
-    }
-
-    hasVoted(optionId) {
-        return this.myVotes.has(optionId);
-    }
-
-    getMyVotedOption() {
-        return Array.from(this.myVotes)[0] || null;
-    }
-
-    generatePollId() {
-        return `poll-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-
-    saveToLocalStorage() {
-        // Save all available polls
-        const pollsData = Array.from(this.availablePolls.values());
-        localStorage.setItem('p2p-polls-list', JSON.stringify(pollsData));
-        
-        // Save current poll separately
-        if (this.currentPoll) {
-            localStorage.setItem('p2p-poll-current', JSON.stringify(this.currentPoll));
-        } else {
-            localStorage.removeItem('p2p-poll-current');
-        }
-        
-        localStorage.setItem('p2p-poll-my-votes', JSON.stringify(Array.from(this.myVotes)));
-    }
-
-    loadFromLocalStorage() {
-        try {
-            const savedPollsList = localStorage.getItem('p2p-polls-list');
-            const savedVotes = localStorage.getItem('p2p-poll-my-votes');
-            
-            if (savedPollsList) {
-                const polls = JSON.parse(savedPollsList);
-                this.availablePolls.clear();
-                polls.forEach(poll => {
-                    this.availablePolls.set(poll.id, poll);
-                });
-                
-                if (this.onPollsListUpdated) {
-                    this.onPollsListUpdated(polls);
-                }
-            }
-            
-            if (savedVotes) {
-                this.myVotes = new Set(JSON.parse(savedVotes));
-                
-                // Validate votes against current poll
-                const currentPoll = this.currentPoll || this.availablePolls.values().next().value;
-                if (currentPoll) {
-                    this.validateMyVotes(currentPoll);
-                }
-            }
-        } catch (error) {
-            console.error('Failed to load from localStorage:', error);
-        }
-    }
-
-    clearData() {
-        this.currentPoll = null;
-        this.availablePolls.clear();
-        this.myVotes.clear();
-        localStorage.removeItem('p2p-poll-current');
-        localStorage.removeItem('p2p-polls-list');
-        localStorage.removeItem('p2p-poll-my-votes');
-    }
-
-    notifyPollUpdated() {
-        if (this.onPollUpdated) {
-            this.onPollUpdated(this.currentPoll);
-        }
-    }
-}
--- a/js/ui-controller.js
+++ b/js/ui-controller.js
@@ -1,419 +0,0 @@
-class UIController {
-    constructor(peerManager, pollManager) {
-        this.peerManager = peerManager;
-        this.pollManager = pollManager;
-        this.initializeEventListeners();
-    }
-
-    initializeEventListeners() {
-        // Connection controls
-        document.getElementById('join-btn').addEventListener('click', () => this.handleJoinRoom());
-        document.getElementById('copy-id-btn').addEventListener('click', () => this.copyPeerId());
-        
-        // Poll creation
-        document.getElementById('create-poll-btn').addEventListener('click', () => this.handleCreatePoll());
-        document.getElementById('add-option-btn').addEventListener('click', () => this.addOptionInput());
-        
-        // Active poll
-        document.getElementById('add-poll-option-btn').addEventListener('click', () => this.showAddOptionModal());
-        document.getElementById('reset-poll-btn').addEventListener('click', () => this.handleResetPoll());
-        document.getElementById('new-poll-btn').addEventListener('click', () => this.handleNewPoll());
-        
-        // Modal controls
-        document.getElementById('close-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
-        document.getElementById('cancel-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
-        document.getElementById('save-option-btn').addEventListener('click', () => this.handleAddOptionFromModal());
-        
-        // Enter key handlers
-        document.getElementById('room-id').addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') this.handleJoinRoom();
-        });
-        
-        document.getElementById('poll-question').addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') this.handleCreatePoll();
-        });
-        
-        document.getElementById('new-option-input').addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') this.handleAddOptionFromModal();
-        });
-        
-        // Close modal on background click
-        document.getElementById('add-option-modal').addEventListener('click', (e) => {
-            if (e.target.id === 'add-option-modal') {
-                this.hideAddOptionModal();
-            }
-        });
-    }
-
-    handleJoinRoom() {
-        const roomIdInput = document.getElementById('room-id');
-        const peerId = roomIdInput.value.trim();
-        
-        this.showLoading(true);
-        
-        if (peerId) {
-            // Connect to existing peer (host)
-            this.peerManager.joinRoom(peerId)
-                .then(() => {
-                    this.showNotification('Connected to host successfully!', 'success');
-                    this.showPollCreation();
-                })
-                .catch(error => {
-                    this.showNotification('Failed to connect: ' + error.message, 'error');
-                    console.error('Connect error:', error);
-                })
-                .finally(() => {
-                    this.showLoading(false);
-                });
-        } else {
-            // Act as host - just show poll creation
-            this.peerManager.createRoom();
-            this.showNotification('You are the host. Share your Peer ID with others to connect.', 'success');
-            this.showPollCreation();
-            this.showLoading(false);
-        }
-    }
-
-    async copyPeerId() {
-        const peerId = this.peerManager.getPeerId();
-        if (peerId) {
-            try {
-                await navigator.clipboard.writeText(peerId);
-                this.showNotification('Peer ID copied to clipboard!', 'success');
-            } catch (error) {
-                // Fallback for older browsers
-                const textArea = document.createElement('textarea');
-                textArea.value = peerId;
-                document.body.appendChild(textArea);
-                textArea.select();
-                document.execCommand('copy');
-                document.body.removeChild(textArea);
-                this.showNotification('Peer ID copied to clipboard!', 'success');
-            }
-        }
-    }
-
-    handleCreatePoll() {
-        const questionInput = document.getElementById('poll-question');
-        const optionInputs = document.querySelectorAll('.option-text');
-        const options = [];
-
-        console.log('Question input:', questionInput);
-        console.log('Found option inputs:', optionInputs.length);
-
-        // Check if question input exists
-        if (!questionInput) {
-            console.error('Question input not found!');
-            this.showNotification('Error: Question input not found', 'error');
-            return;
-        }
-
-        const question = questionInput.value ? questionInput.value.trim() : '';
-        console.log('Question:', question);
-
-        optionInputs.forEach((input, index) => {
-            console.log(`Input ${index}:`, input, 'value:', input?.value);
-            if (input && typeof input.value !== 'undefined') {
-                const text = input.value.trim();
-                if (text) {
-                    options.push(text);
-                }
-            } else {
-                console.warn(`Input ${index} is invalid or has no value property`);
-            }
-        });
-
-        console.log('Final options:', options);
-
-        if (!question) {
-            this.showNotification('Please enter a poll question', 'error');
-            return;
-        }
-
-        if (options.length < 2) {
-            this.showNotification('Please enter at least 2 options', 'error');
-            return;
-        }
-
-        try {
-            this.pollManager.createPoll(question, options);
-            this.showNotification('Poll created successfully!', 'success');
-        } catch (error) {
-            console.error('Create poll error:', error);
-            this.showNotification('Failed to create poll: ' + error.message, 'error');
-        }
-    }
-
-    showAddOptionModal() {
-        const modal = document.getElementById('add-option-modal');
-        const input = document.getElementById('new-option-input');
-        modal.classList.remove('hidden');
-        input.value = '';
-        input.focus();
-    }
-
-    hideAddOptionModal() {
-        const modal = document.getElementById('add-option-modal');
-        const input = document.getElementById('new-option-input');
-        modal.classList.add('hidden');
-        input.value = '';
-    }
-
-    handleAddOptionFromModal() {
-        const input = document.getElementById('new-option-input');
-        const optionText = input.value.trim();
-        
-        if (!optionText) {
-            this.showNotification('Please enter an option text', 'error');
-            return;
-        }
-        
-        try {
-            this.pollManager.addOption(optionText);
-            this.hideAddOptionModal();
-            this.showNotification('Option added successfully!', 'success');
-        } catch (error) {
-            this.showNotification('Failed to add option: ' + error.message, 'error');
-        }
-    }
-
-    handleAddPollOption() {
-        this.showAddOptionModal();
-    }
-
-    handleResetPoll() {
-        if (confirm('Are you sure you want to reset all votes?')) {
-            try {
-                this.pollManager.resetPoll();
-                this.showNotification('Poll reset successfully!', 'success');
-            } catch (error) {
-                this.showNotification('Failed to reset poll: ' + error.message, 'error');
-            }
-        }
-    }
-
-    handleNewPoll() {
-        this.pollManager.createNewPoll();
-        this.showPollCreation();
-        this.clearPollForm();
-    }
-
-    addOptionInput() {
-        const container = document.getElementById('options-container');
-        const optionCount = container.children.length;
-        
-        const optionDiv = document.createElement('div');
-        optionDiv.className = 'option-input';
-        optionDiv.innerHTML = `
-            <input type="text" class="option-text" placeholder="Option ${optionCount + 1}">
-            <button class="remove-option-btn">Remove</button>
-        `;
-
-        container.appendChild(optionDiv);
-        this.updateOptionRemoveButtons();
-
-        // Add event listener to new input
-        const newInput = optionDiv.querySelector('.option-text');
-        newInput.addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') this.handleCreatePoll();
-        });
-
-        // Add event listener to remove button
-        const removeBtn = optionDiv.querySelector('.remove-option-btn');
-        removeBtn.addEventListener('click', () => {
-            optionDiv.remove();
-            this.updateOptionRemoveButtons();
-            this.updateOptionPlaceholders();
-        });
-
-        // Focus on new input
-        newInput.focus();
-    }
-
-    updateOptionRemoveButtons() {
-        const optionInputs = document.querySelectorAll('.option-input');
-        const removeButtons = document.querySelectorAll('.remove-option-btn');
-        
-        removeButtons.forEach((btn, index) => {
-            if (optionInputs.length <= 2) {
-                btn.classList.add('hidden');
-            } else {
-                btn.classList.remove('hidden');
-            }
-        });
-    }
-
-    updateOptionPlaceholders() {
-        const optionInputs = document.querySelectorAll('.option-text');
-        optionInputs.forEach((input, index) => {
-            input.placeholder = `Option ${index + 1}`;
-        });
-    }
-
-    clearPollForm() {
-        document.getElementById('poll-question').value = '';
-        const container = document.getElementById('options-container');
-        container.innerHTML = `
-            <div class="option-input">
-                <input type="text" class="option-text" placeholder="Option 1">
-                <button class="remove-option-btn hidden">Remove</button>
-            </div>
-            <div class="option-input">
-                <input type="text" class="option-text" placeholder="Option 2">
-                <button class="remove-option-btn hidden">Remove</button>
-            </div>
-        `;
-        this.updateOptionRemoveButtons();
-    }
-
-    showPollCreation() {
-        document.getElementById('connection-section').classList.add('hidden');
-        document.getElementById('poll-creation').classList.remove('hidden');
-        document.getElementById('active-poll').classList.add('hidden');
-    }
-
-    showActivePoll() {
-        document.getElementById('connection-section').classList.add('hidden');
-        document.getElementById('poll-creation').classList.add('hidden');
-        document.getElementById('active-poll').classList.remove('hidden');
-    }
-
-    updatePeerId(peerId) {
-        const element = document.getElementById('peer-id');
-        if (element) {
-            element.textContent = peerId || 'Loading...';
-        }
-    }
-
-    renderPoll(poll) {
-        if (!poll) return;
-
-        this.showActivePoll();
-        
-        // Update poll question
-        document.getElementById('poll-question-display').textContent = poll.question;
-        
-        // Render options
-        const optionsContainer = document.getElementById('poll-options');
-        optionsContainer.innerHTML = '';
-        
-        const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
-        const myVotedOption = this.pollManager.getMyVotedOption();
-        
-        poll.options.forEach(option => {
-            const optionDiv = document.createElement('div');
-            optionDiv.className = 'poll-option';
-            
-            const hasVoted = this.pollManager.hasVoted(option.id);
-            const myVotedOption = this.pollManager.getMyVotedOption();
-            
-            console.log(`Option ${option.id}: hasVoted=${hasVoted}, myVotedOption=${myVotedOption}`);
-            
-            if (hasVoted) {
-                optionDiv.classList.add('voted');
-            } else if (myVotedOption) {
-                // User has voted but not for this option - this is a change vote option
-                optionDiv.classList.add('change-vote');
-            }
-            
-            const percentage = totalVotes > 0 ? (option.votes / totalVotes * 100).toFixed(1) : 0;
-            
-            optionDiv.innerHTML = `
-                <div class="option-header">
-                    <span class="option-text">${option.text}</span>
-                    <span class="vote-count">${option.votes} votes</span>
-                </div>
-                <div class="vote-bar">
-                    <div class="vote-fill" style="width: ${percentage}%"></div>
-                </div>
-            `;
-            
-            optionDiv.addEventListener('click', () => {
-                const myVotedOption = this.pollManager.getMyVotedOption();
-                
-                if (this.pollManager.hasVoted(option.id)) {
-                    // Clicking your current vote - unvote
-                    if (confirm('Remove your vote?')) {
-                        const success = this.pollManager.unvote();
-                        if (success) {
-                            this.showNotification('Vote removed!', 'success');
-                        }
-                    }
-                } else {
-                    // Either first vote or changing vote
-                    const success = this.pollManager.vote(option.id);
-                    if (success) {
-                        if (myVotedOption) {
-                            this.showNotification('Vote changed successfully!', 'success');
-                        } else {
-                            this.showNotification('Vote recorded!', 'success');
-                        }
-                    }
-                }
-            });
-            
-            optionsContainer.appendChild(optionDiv);
-        });
-    }
-
-    showNotification(message, type = 'info') {
-        const notification = document.getElementById('notification');
-        notification.textContent = message;
-        notification.className = `notification ${type}`;
-        notification.classList.remove('hidden');
-        
-        setTimeout(() => {
-            notification.classList.add('hidden');
-        }, 3000);
-    }
-
-    showLoading(show) {
-        const overlay = document.getElementById('loading-overlay');
-        if (show) {
-            overlay.classList.remove('hidden');
-        } else {
-            overlay.classList.add('hidden');
-        }
-    }
-
-    updatePeersList() {
-        // Use the peer manager's updatePeersList method
-        this.peerManager.updatePeersList();
-    }
-
-    updatePollsList(polls) {
-        const pollsList = document.getElementById('polls-list');
-        
-        if (!pollsList) return;
-        
-        if (polls.length === 0) {
-            pollsList.innerHTML = '<p class="no-polls">No polls created yet</p>';
-            return;
-        }
-        
-        pollsList.innerHTML = '';
-        
-        polls.forEach(poll => {
-            const pollDiv = document.createElement('div');
-            pollDiv.className = 'poll-item';
-            
-            if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === poll.id) {
-                pollDiv.classList.add('active');
-            }
-            
-            const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
-            const createdDate = new Date(poll.createdAt).toLocaleString();
-            
-            pollDiv.innerHTML = `
-                <div class="poll-item-title">${poll.question}</div>
-                <div class="poll-item-meta">${totalVotes} votes • ${createdDate}</div>
-            `;
-            
-            pollDiv.addEventListener('click', () => {
-                this.pollManager.selectPoll(poll.id);
-            });
-            
-            pollsList.appendChild(pollDiv);
-        });
-    }
-}
--- a/server/.env.example
+++ b/server/.env.example
@@ -0,0 +1,4 @@
+PORT=3000
+YJS_WS_PORT=1234
+NODE_ENV=development
+CORS_ORIGIN=http://localhost:5173
--- a/server/.gitignore
+++ b/server/.gitignore
@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.env
+*.log
+.DS_Store
--- a/server/package-lock.json
+++ b/server/package-lock.json
--- a/server/package.json
+++ b/server/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "p2p-poll-server",
+  "version": "1.0.0",
+  "description": "Backend server for P2P polling app with Yjs and WebRTC signaling",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "yjs",
+    "websocket",
+    "webrtc",
+    "p2p"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "ws": "^8.14.2",
+    "y-websocket": "^1.5.0",
+    "yjs": "^13.6.8",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.15",
+    "@types/express": "^4.17.20",
+    "@types/node": "^20.9.0",
+    "@types/ws": "^8.5.8",
+    "tsx": "^4.6.2",
+    "typescript": "^5.2.2"
+  }
+}
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -0,0 +1,59 @@
+import express from 'express';
+import http from 'http';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { createYjsServer } from './yjs-server';
+import { createSignalingServer } from './signaling-server';
+import { logger } from './utils/logger';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || ['http://localhost:5173', 'http://localhost:5174', 'http://localhost:5175'],
+  credentials: true
+}));
+
+app.use(express.json());
+
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'ok', 
+    timestamp: new Date().toISOString(),
+    services: {
+      yjs: 'running',
+      signaling: 'running'
+    }
+  });
+});
+
+app.get('/', (req, res) => {
+  res.json({ 
+    message: 'P2P Poll Server',
+    endpoints: {
+      health: '/health',
+      yjs: 'ws://localhost:' + PORT + '/yjs',
+      signaling: 'ws://localhost:' + PORT + '/signal'
+    }
+  });
+});
+
+const server = http.createServer(app);
+
+createYjsServer(server, PORT as number);
+createSignalingServer(server);
+
+server.listen(PORT, () => {
+  logger.info(`Server running on port ${PORT}`);
+  logger.info(`Yjs WebSocket: ws://localhost:${PORT}/yjs`);
+  logger.info(`Signaling WebSocket: ws://localhost:${PORT}/signal`);
+});
+
+process.on('SIGTERM', () => {
+  logger.info('SIGTERM signal received: closing HTTP server');
+  server.close(() => {
+    logger.info('HTTP server closed');
+  });
+});
--- a/server/src/signaling-server.ts
+++ b/server/src/signaling-server.ts
@@ -0,0 +1,305 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import http from 'http';
+import { SignalingMessage, SignalingMessageSchema } from './types/poll.types';
+import { logger } from './utils/logger';
+
+interface Client {
+  id: string;
+  ws: WebSocket;
+  roomId: string;
+  lastSeen: number;
+  messageCount: number;
+  lastMessageTime: number;
+}
+
+export function createSignalingServer(server: http.Server) {
+  const wss = new WebSocketServer({ 
+    noServer: true
+  });
+
+  // Handle upgrade requests for /signal path
+  server.on('upgrade', (request, socket, head) => {
+    const pathname = request.url || '';
+    
+    if (pathname === '/signal' || pathname.startsWith('/signal?')) {
+      logger.info(`[SIGNALING] Upgrade request for path: ${pathname}`);
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit('connection', ws, request);
+      });
+    }
+  });
+
+  const clients = new Map<string, Client>();
+  const rooms = new Map<string, Set<string>>();
+  const roomPasswords = new Map<string, string>();
+  const HEARTBEAT_INTERVAL = 30000;
+  const CLIENT_TIMEOUT = 60000;
+  const RATE_LIMIT_WINDOW = 1000;
+  const RATE_LIMIT_MAX = 10;
+
+  const heartbeatInterval = setInterval(() => {
+    const now = Date.now();
+    clients.forEach((client, clientId) => {
+      if (now - client.lastSeen > CLIENT_TIMEOUT) {
+        logger.info(`Client ${clientId} timed out, removing...`);
+        handleClientLeave(clientId);
+      } else {
+        client.ws.send(JSON.stringify({ type: 'ping' }));
+      }
+    });
+  }, HEARTBEAT_INTERVAL);
+
+  wss.on('connection', (ws: WebSocket) => {
+    let clientId: string | null = null;
+    const tempClientId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    logger.info(`[SIGNALING] New WebSocket connection (temp: ${tempClientId})`);
+
+    ws.on('message', (data: Buffer) => {
+      try {
+        const parsed = JSON.parse(data.toString());
+        const validationResult = SignalingMessageSchema.safeParse(parsed);
+        
+        if (!validationResult.success) {
+          logger.error('Invalid signaling message:', validationResult.error);
+          ws.send(JSON.stringify({ 
+            type: 'error', 
+            message: 'Invalid message format',
+            errors: validationResult.error.issues 
+          }));
+          return;
+        }
+        
+        const message: SignalingMessage = validationResult.data;
+
+        if (clientId) {
+          const client = clients.get(clientId);
+          if (client) {
+            const now = Date.now();
+            if (now - client.lastMessageTime < RATE_LIMIT_WINDOW) {
+              client.messageCount++;
+              if (client.messageCount > RATE_LIMIT_MAX) {
+                logger.warn(`Client ${clientId} exceeded rate limit`);
+                ws.send(JSON.stringify({ 
+                  type: 'error', 
+                  message: 'Rate limit exceeded' 
+                }));
+                return;
+              }
+            } else {
+              client.messageCount = 1;
+              client.lastMessageTime = now;
+            }
+          }
+        }
+
+        switch (message.type) {
+          case 'subscribe':
+            // y-webrtc subscribe message - client wants to join topics
+            if (message.topics) {
+              message.topics.forEach((topic: string) => {
+                if (!rooms.has(topic)) {
+                  rooms.set(topic, new Set());
+                }
+                const tempId = `sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+                clientId = tempId;
+                rooms.get(topic)!.add(tempId);
+                clients.set(tempId, {
+                  id: tempId,
+                  ws,
+                  roomId: topic,
+                  lastSeen: Date.now(),
+                  messageCount: 0,
+                  lastMessageTime: Date.now()
+                });
+                logger.info(`[SIGNALING] Client subscribed to topic: ${topic}`);
+              });
+            }
+            break;
+
+          case 'unsubscribe':
+            // y-webrtc unsubscribe message
+            if (message.topics && clientId) {
+              message.topics.forEach((topic: string) => {
+                const room = rooms.get(topic);
+                if (room && clientId) {
+                  room.delete(clientId);
+                  if (room.size === 0) {
+                    rooms.delete(topic);
+                  }
+                }
+              });
+            }
+            break;
+
+          case 'publish':
+            // y-webrtc publish message - broadcast to all subscribers of a topic
+            if (message.topic) {
+              const topic = message.topic;
+              const room = rooms.get(topic);
+              if (room) {
+                room.forEach((subscriberId) => {
+                  const subscriber = clients.get(subscriberId);
+                  if (subscriber && subscriber.ws !== ws && subscriber.ws.readyState === WebSocket.OPEN) {
+                    subscriber.ws.send(JSON.stringify({
+                      type: 'publish',
+                      topic: topic,
+                      data: message.data
+                    }));
+                  }
+                });
+              }
+            }
+            break;
+
+          case 'join':
+            clientId = message.from || `client-${Date.now()}`;
+            const roomId = message.roomId || 'default-room';
+            
+            const roomPassword = roomPasswords.get(roomId);
+            if (roomPassword && message.password !== roomPassword) {
+              logger.warn(`Client ${clientId} failed password authentication for room ${roomId}`);
+              ws.send(JSON.stringify({ 
+                type: 'error', 
+                message: 'Invalid room password' 
+              }));
+              return;
+            }
+            
+            clients.set(clientId, { 
+              id: clientId, 
+              ws, 
+              roomId, 
+              lastSeen: Date.now(),
+              messageCount: 0,
+              lastMessageTime: Date.now()
+            });
+            
+            if (!rooms.has(roomId)) {
+              rooms.set(roomId, new Set());
+            }
+            rooms.get(roomId)!.add(clientId);
+
+            logger.info(`Client ${clientId} joined room ${roomId}`);
+
+            const roomClients = Array.from(rooms.get(roomId)!).filter(id => id !== clientId);
+            ws.send(JSON.stringify({
+              type: 'peers',
+              peers: roomClients
+            }));
+
+            roomClients.forEach(peerId => {
+              const peer = clients.get(peerId);
+              if (peer && peer.ws.readyState === WebSocket.OPEN) {
+                peer.ws.send(JSON.stringify({
+                  type: 'peer-joined',
+                  peerId: clientId
+                }));
+              }
+            });
+            break;
+
+          case 'offer':
+          case 'answer':
+          case 'ice-candidate':
+            if (message.to) {
+              const targetClient = clients.get(message.to);
+              if (targetClient && targetClient.ws.readyState === WebSocket.OPEN) {
+                targetClient.ws.send(JSON.stringify({
+                  type: message.type,
+                  from: message.from,
+                  data: message.data
+                }));
+              }
+            }
+            break;
+
+          case 'leave':
+            if (message.from) {
+              handleClientLeave(message.from);
+            }
+            break;
+
+          case 'create-room':
+            if (message.roomId && message.password) {
+              roomPasswords.set(message.roomId, message.password);
+              logger.info(`Room ${message.roomId} created with password protection`);
+              ws.send(JSON.stringify({ 
+                type: 'room-created', 
+                roomId: message.roomId 
+              }));
+            }
+            break;
+
+          case 'ping':
+            if (clientId) {
+              const client = clients.get(clientId);
+              if (client) {
+                client.lastSeen = Date.now();
+                client.ws.send(JSON.stringify({ type: 'pong', from: 'server' }));
+              }
+            }
+            break;
+
+          case 'pong':
+            if (clientId) {
+              const client = clients.get(clientId);
+              if (client) {
+                client.lastSeen = Date.now();
+              }
+            }
+            break;
+        }
+      } catch (error) {
+        logger.error('Error processing signaling message:', error);
+      }
+    });
+
+    ws.on('close', () => {
+      if (clientId) {
+        handleClientLeave(clientId);
+      }
+    });
+
+    ws.on('error', (error) => {
+      logger.error('WebSocket error:', error);
+    });
+  });
+
+  function handleClientLeave(clientId: string) {
+    const client = clients.get(clientId);
+    if (client) {
+      const roomId = client.roomId;
+      const room = rooms.get(roomId);
+      
+      if (room) {
+        room.delete(clientId);
+        
+        room.forEach(peerId => {
+          const peer = clients.get(peerId);
+          if (peer && peer.ws.readyState === WebSocket.OPEN) {
+            peer.ws.send(JSON.stringify({
+              type: 'peer-left',
+              peerId: clientId
+            }));
+          }
+        });
+
+        if (room.size === 0) {
+          rooms.delete(roomId);
+        }
+      }
+      
+      clients.delete(clientId);
+      logger.info(`Client ${clientId} left room ${roomId}`);
+    }
+  }
+
+  wss.on('close', () => {
+    clearInterval(heartbeatInterval);
+    logger.info('Signaling server closed');
+  });
+
+  logger.info('Signaling server running at path /signal');
+  
+  return wss;
+}
--- a/server/src/types/poll.types.ts
+++ b/server/src/types/poll.types.ts
@@ -0,0 +1,40 @@
+import { z } from 'zod';
+
+export interface PollOption {
+  id: string;
+  text: string;
+  votes: number;
+  votedBy: string[];
+  createdBy: string;
+  timestamp: number;
+}
+
+export interface Poll {
+  id: string;
+  question: string;
+  createdBy: string;
+  timestamp: number;
+  options: PollOption[];
+}
+
+export const SignalingMessageSchema = z.object({
+  type: z.enum(['offer', 'answer', 'ice-candidate', 'join', 'leave', 'ping', 'pong', 'create-room', 'subscribe', 'unsubscribe', 'publish', 'signal']),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  data: z.any().optional(),
+  roomId: z.string().optional(),
+  password: z.string().optional(),
+  topics: z.array(z.string()).optional(),
+  topic: z.string().optional()
+});
+
+export interface SignalingMessage {
+  type: 'offer' | 'answer' | 'ice-candidate' | 'join' | 'leave' | 'ping' | 'pong' | 'create-room' | 'subscribe' | 'unsubscribe' | 'publish' | 'signal';
+  from?: string;
+  to?: string;
+  data?: any;
+  roomId?: string;
+  password?: string;
+  topics?: string[];
+  topic?: string;
+}
--- a/server/src/utils/logger.ts
+++ b/server/src/utils/logger.ts
@@ -0,0 +1,115 @@
+type LogLevel = 'info' | 'error' | 'warn' | 'debug';
+type LogContext = Record<string, any>;
+
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  context?: LogContext;
+}
+
+class Logger {
+  private context: LogContext = {};
+  private timers: Map<string, number> = new Map();
+
+  setContext(ctx: LogContext): void {
+    this.context = { ...this.context, ...ctx };
+  }
+
+  clearContext(): void {
+    this.context = {};
+  }
+
+  private formatLog(level: LogLevel, message: string, args: any[]): LogEntry {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      context: Object.keys(this.context).length > 0 ? { ...this.context } : undefined
+    };
+
+    if (args.length > 0) {
+      if (entry.context) {
+        entry.context.args = args;
+      } else {
+        entry.context = { args };
+      }
+    }
+
+    return entry;
+  }
+
+  private log(level: LogLevel, message: string, ...args: any[]): void {
+    const entry = this.formatLog(level, message, args);
+    const logString = JSON.stringify(entry);
+    
+    switch (level) {
+      case 'info':
+        console.log(logString);
+        break;
+      case 'error':
+        console.error(logString);
+        break;
+      case 'warn':
+        console.warn(logString);
+        break;
+      case 'debug':
+        if (process.env.NODE_ENV === 'development') {
+          console.debug(logString);
+        }
+        break;
+    }
+  }
+
+  info(message: string, ...args: any[]): void {
+    this.log('info', message, ...args);
+  }
+
+  error(message: string, ...args: any[]): void {
+    this.log('error', message, ...args);
+  }
+
+  warn(message: string, ...args: any[]): void {
+    this.log('warn', message, ...args);
+  }
+
+  debug(message: string, ...args: any[]): void {
+    this.log('debug', message, ...args);
+  }
+
+  startTimer(label: string): void {
+    this.timers.set(label, Date.now());
+  }
+
+  endTimer(label: string): number {
+    const startTime = this.timers.get(label);
+    if (!startTime) {
+      this.warn(`Timer '${label}' not found`);
+      return 0;
+    }
+    const duration = Date.now() - startTime;
+    this.timers.delete(label);
+    this.debug(`Timer '${label}': ${duration}ms`);
+    return duration;
+  }
+
+  time<T>(label: string, fn: () => T): T {
+    this.startTimer(label);
+    try {
+      return fn();
+    } finally {
+      this.endTimer(label);
+    }
+  }
+
+  async timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T> {
+    this.startTimer(label);
+    try {
+      return await fn();
+    } finally {
+      this.endTimer(label);
+    }
+  }
+}
+
+export const logger = new Logger();
--- a/server/src/yjs-server.ts
+++ b/server/src/yjs-server.ts
@@ -0,0 +1,51 @@
+import { WebSocketServer } from 'ws';
+// @ts-ignore
+import { setupWSConnection } from 'y-websocket/bin/utils';
+import http from 'http';
+import { logger } from './utils/logger';
+
+export function createYjsServer(server: http.Server, port: number) {
+  const wss = new WebSocketServer({ 
+    noServer: true
+  });
+
+  // Handle upgrade requests for /yjs/* paths
+  server.on('upgrade', (request, socket, head) => {
+    const pathname = request.url || '';
+    
+    if (pathname.startsWith('/yjs')) {
+      logger.info(`[YJS] Upgrade request for path: ${pathname}`);
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit('connection', ws, request);
+      });
+    }
+  });
+
+  wss.on('connection', (ws, req) => {
+    const url = req.url || 'unknown';
+    const remoteAddress = req.socket.remoteAddress || 'unknown';
+    logger.info(`[YJS] New connection from ${remoteAddress}, URL: ${url}`);
+    
+    // Log when connection closes
+    ws.on('close', () => {
+      logger.info(`[YJS] Connection closed from ${remoteAddress}`);
+    });
+    
+    ws.on('error', (error) => {
+      logger.error(`[YJS] Connection error from ${remoteAddress}:`, error);
+    });
+    
+    // y-websocket automatically handles docName from the URL path
+    // The room name is passed as part of the URL: /yjs/room-name
+    // We don't need to manually extract it
+    setupWSConnection(ws, req, { gc: true });
+  });
+
+  wss.on('error', (error) => {
+    logger.error('Yjs WebSocket server error:', error);
+  });
+
+  logger.info(`Yjs WebSocket server running on port ${port} at path /yjs`);
+  
+  return wss;
+}
--- a/server/tsconfig.json
+++ b/server/tsconfig.json
@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}