783668b015
Some checks failed
CI / Frontend Lint & Type Check (push) Has been cancelled
CI / Frontend Build (push) Has been cancelled
CI / Backend Lint (push) Has been cancelled
CI / Backend Tests (push) Has been cancelled
CI / Docker Build (push) Has been cancelled
CI / Security Scan (push) Has been cancelled
Deploy / Build & Push Images (push) Has been cancelled
Deploy / Deploy to Server (push) Has been cancelled
Deploy / Notify (push) Has been cancelled
🚀 MARKET CONCEPT IMPLEMENTATION
Backend:
- Added /auctions/feed unified endpoint combining Pounce Direct + external auctions
- Implemented Pounce Score v2.0 with market signals (length, TLD, bids, age)
- Added vanity filter for premium domains (non-auth users)
- Integrated DomainListing model for Pounce Direct
Frontend:
- Refactored terminal/market page with Pounce Direct hierarchy
- Updated public auctions page with Pounce Exclusive section
- Added api.getMarketFeed() to API client
- Converted /market to redirect to /auctions
Documentation:
- Created MARKET_CONCEPT.md with full unicorn roadmap
- Created ZONE_FILE_ACCESS.md with Verisign access guide
- Updated todos and progress tracking
Cleanup:
- Deleted empty legacy folders (dashboard, portfolio, settings, watchlist, careers)
1416 lines
64 KiB
Markdown
1416 lines
64 KiB
Markdown
# 🎯 POUNCE MARKET — Das Konzept für die Unicorn-Journey
|
||
|
||
---
|
||
|
||
# 📦 TEIL 1: BESTANDSAUFNAHME — Was haben wir?
|
||
|
||
## Übersicht: Code-Inventar
|
||
|
||
### ✅ BEHALTEN — Funktioniert gut, Vision-konform
|
||
|
||
| Komponente | Pfad | Status | Beschreibung |
|
||
|------------|------|--------|--------------|
|
||
| **Listings API** | `backend/app/api/listings.py` | ✅ Vollständig | Pounce Direct Marketplace mit DNS-Verifizierung |
|
||
| **Listing Model** | `backend/app/models/listing.py` | ✅ Vollständig | DomainListing, ListingInquiry, ListingView |
|
||
| **My Listings Page** | `frontend/src/app/terminal/listing/page.tsx` | ✅ Vollständig | Seller Dashboard mit Verification Wizard |
|
||
| **Public Marketplace** | `frontend/src/app/buy/page.tsx` | ✅ Vollständig | Öffentliche Browse-Seite für Listings |
|
||
| **Listing Detail** | `frontend/src/app/buy/[slug]/page.tsx` | ✅ Vollständig | Öffentliche Landing Page pro Listing |
|
||
| **Sniper Alerts API** | `backend/app/api/sniper_alerts.py` | ✅ Vollständig | Alert-Matching für Auktionen |
|
||
| **Sniper Alert Model** | `backend/app/models/sniper_alert.py` | ✅ Vollständig | SniperAlert, SniperAlertMatch |
|
||
| **Scheduler** | `backend/app/scheduler.py` | ✅ Vollständig | APScheduler mit Scraping, Alerts, Checks |
|
||
| **Valuation Service** | `backend/app/services/valuation.py` | ✅ Vollständig | Pounce Score Berechnung |
|
||
| **TLD Prices API** | `backend/app/api/tld_prices.py` | ✅ Vollständig | Intel/Pricing Feature |
|
||
| **TLD Scraper** | `backend/app/services/tld_scraper/` | ✅ Funktioniert | Porkbun + Aggregator |
|
||
| **Portfolio API** | `backend/app/api/portfolio.py` | ✅ Vollständig | Eigene Domains verwalten |
|
||
| **Domain Health** | `backend/app/services/domain_health.py` | ✅ Vollständig | 4-Layer Monitoring |
|
||
| **SEO Analyzer** | `backend/app/services/seo_analyzer.py` | ✅ Vollständig | Moz API Integration |
|
||
| **Email Service** | `backend/app/services/email_service.py` | ✅ Vollständig | Notifications |
|
||
| **Stripe Service** | `backend/app/services/stripe_service.py` | ✅ Vollständig | Subscriptions |
|
||
|
||
---
|
||
|
||
### ⚠️ ÜBERARBEITEN — Funktioniert, aber Optimierung nötig
|
||
|
||
| Komponente | Pfad | Problem | Lösung |
|
||
|------------|------|---------|--------|
|
||
| **Auction Scraper** | `backend/app/services/auction_scraper.py` | Scraping ist fragil, oft leer | API-First + Fallback-Logik |
|
||
| **Auctions API** | `backend/app/api/auctions.py` | Keine Pounce Direct Integration | Unified Feed erstellen |
|
||
| **Market Page** | `frontend/src/app/terminal/market/page.tsx` | Zeigt nur externe Auktionen | Pounce Direct integrieren |
|
||
| **Pounce Score** | In `market/page.tsx` | Zu simpel (nur Length+TLD) | Erweitern um Markt-Signale |
|
||
| **Public Auctions** | `frontend/src/app/auctions/page.tsx` | Kein Pounce Direct Highlight | Visuelle Hierarchie |
|
||
|
||
---
|
||
|
||
### ❌ ENTFERNEN / KONSOLIDIEREN — Redundant oder veraltet
|
||
|
||
| Komponente | Pfad | Grund | Aktion |
|
||
|------------|------|-------|--------|
|
||
| **Leere Ordner** | `frontend/src/app/dashboard/` | Leer (Legacy von /command) | Löschen |
|
||
| **Leere Ordner** | `frontend/src/app/portfolio/` | Leer (Legacy) | Löschen |
|
||
| **Leere Ordner** | `frontend/src/app/settings/` | Leer (Legacy) | Löschen |
|
||
| **Leere Ordner** | `frontend/src/app/watchlist/` | Leer (Legacy) | Löschen |
|
||
| **Leere Ordner** | `frontend/src/app/careers/` | Kein Inhalt | Löschen oder TODO |
|
||
| **Intelligence Redirect** | `frontend/src/app/intelligence/page.tsx` | Redirect zu /tld-pricing | Prüfen ob noch nötig |
|
||
| **Market Public** | `frontend/src/app/market/page.tsx` | Duplikat? Prüfen | Ggf. konsolidieren mit /auctions |
|
||
|
||
---
|
||
|
||
## Detaillierte Analyse pro Bereich
|
||
|
||
### 1. BACKEND: API Routes (`backend/app/api/`)
|
||
|
||
```
|
||
backend/app/api/
|
||
├── __init__.py ✅ Router-Registration
|
||
├── admin.py ✅ Admin Panel APIs
|
||
├── auctions.py ⚠️ Überarbeiten (Unified Feed)
|
||
├── auth.py ✅ Login/Register/JWT
|
||
├── blog.py ✅ Blog Feature
|
||
├── check.py ✅ Domain Availability Check
|
||
├── contact.py ✅ Kontaktformular
|
||
├── deps.py ✅ Dependencies
|
||
├── domains.py ✅ Watchlist
|
||
├── listings.py ✅ Pounce Direct Marketplace
|
||
├── oauth.py ✅ Google/GitHub OAuth
|
||
├── portfolio.py ✅ Portfolio Management
|
||
├── price_alerts.py ✅ TLD Price Alerts
|
||
├── seo.py ✅ SEO Juice (Tycoon)
|
||
├── sniper_alerts.py ✅ Auction Sniper Alerts
|
||
├── subscription.py ✅ Stripe Integration
|
||
├── tld_prices.py ✅ TLD Pricing Data
|
||
└── webhooks.py ✅ Stripe Webhooks
|
||
```
|
||
|
||
**Aktion:**
|
||
- `auctions.py`: Unified Feed Endpoint hinzufügen der Pounce Direct + External kombiniert
|
||
|
||
---
|
||
|
||
### 2. BACKEND: Services (`backend/app/services/`)
|
||
|
||
```
|
||
backend/app/services/
|
||
├── auction_scraper.py ⚠️ Fallback-Logik verbessern
|
||
├── auth.py ✅ Behalten
|
||
├── domain_checker.py ✅ Behalten
|
||
├── domain_health.py ✅ Behalten
|
||
├── email_service.py ✅ Behalten
|
||
├── price_tracker.py ✅ Behalten
|
||
├── seo_analyzer.py ✅ Behalten
|
||
├── stripe_service.py ✅ Behalten
|
||
├── valuation.py ⚠️ Pounce Score v2.0 integrieren
|
||
└── tld_scraper/
|
||
├── aggregator.py ✅ Behalten
|
||
├── base.py ✅ Behalten
|
||
├── porkbun.py ✅ Behalten
|
||
└── tld_list.py ✅ Behalten
|
||
```
|
||
|
||
**Aktionen:**
|
||
1. `auction_scraper.py`: Methode `scrape_with_fallback()` hinzufügen
|
||
2. `valuation.py`: Pounce Score v2.0 mit Market Signals
|
||
|
||
---
|
||
|
||
### 3. BACKEND: Models (`backend/app/models/`)
|
||
|
||
```
|
||
backend/app/models/
|
||
├── admin_log.py ✅ Behalten
|
||
├── auction.py ✅ DomainAuction, AuctionScrapeLog
|
||
├── blog.py ✅ Behalten
|
||
├── domain.py ✅ Domain, DomainCheck
|
||
├── listing.py ✅ DomainListing, ListingInquiry, ListingView
|
||
├── newsletter.py ✅ Behalten
|
||
├── portfolio.py ✅ PortfolioDomain
|
||
├── price_alert.py ✅ TLDPriceAlert
|
||
├── seo_data.py ✅ DomainSEOData
|
||
├── sniper_alert.py ✅ SniperAlert, SniperAlertMatch
|
||
├── subscription.py ✅ Subscription, tier config
|
||
├── tld_price.py ✅ TLDPrice, TLDInfo
|
||
└── user.py ✅ User
|
||
```
|
||
|
||
**Status:** Alle Models sind sauber und Vision-konform. Keine Änderungen nötig.
|
||
|
||
---
|
||
|
||
### 4. FRONTEND: Terminal (Authenticated) (`frontend/src/app/terminal/`)
|
||
|
||
```
|
||
frontend/src/app/terminal/
|
||
├── page.tsx ✅ Redirect zu /radar
|
||
├── radar/page.tsx ✅ Dashboard
|
||
├── market/page.tsx ⚠️ Pounce Direct integrieren!
|
||
├── intel/page.tsx ✅ TLD Overview
|
||
├── intel/[tld]/page.tsx ✅ TLD Detail
|
||
├── watchlist/page.tsx ✅ Domain Monitoring
|
||
├── listing/page.tsx ✅ My Listings (Seller Dashboard)
|
||
├── settings/page.tsx ✅ User Settings
|
||
└── welcome/page.tsx ✅ Onboarding
|
||
```
|
||
|
||
**Aktionen:**
|
||
1. `market/page.tsx`: Pounce Direct Listings im Feed anzeigen
|
||
2. `market/page.tsx`: Visuelle Hierarchie (💎 Pounce vs 🏢 External)
|
||
|
||
---
|
||
|
||
### 5. FRONTEND: Public Pages (`frontend/src/app/`)
|
||
|
||
```
|
||
frontend/src/app/
|
||
├── page.tsx ✅ Landing Page
|
||
├── auctions/page.tsx ⚠️ Pounce Direct hervorheben
|
||
├── buy/page.tsx ✅ Marketplace Browse
|
||
├── buy/[slug]/page.tsx ✅ Listing Detail
|
||
├── tld-pricing/ ✅ TLD Intel Public
|
||
├── pricing/page.tsx ✅ Subscription Tiers
|
||
├── blog/ ✅ Blog
|
||
├── login/page.tsx ✅ Auth
|
||
├── register/page.tsx ✅ Auth
|
||
└── ... ✅ Legal, Contact, etc.
|
||
```
|
||
|
||
**Aktionen:**
|
||
1. `auctions/page.tsx`: "💎 Pounce Direct" Listings prominent anzeigen
|
||
2. Konsolidieren: `/market/` mit `/auctions/` zusammenführen?
|
||
|
||
---
|
||
|
||
### 6. FRONTEND: API Client (`frontend/src/lib/api.ts`)
|
||
|
||
**Status:** ✅ Vollständig
|
||
|
||
Enthält alle nötigen Methoden:
|
||
- `getAuctions()` - Externe Auktionen
|
||
- `getMarketplaceListings()` - TODO: Backend anbinden (aktuell leere Liste)
|
||
|
||
**Aktion:**
|
||
- `getMarketplaceListings()` → Backend Endpoint `/listings` anbinden
|
||
|
||
---
|
||
|
||
## Zusammenfassung: Cleanup-Liste
|
||
|
||
### Sofort löschen (leere Ordner):
|
||
```bash
|
||
rm -rf frontend/src/app/dashboard/
|
||
rm -rf frontend/src/app/portfolio/
|
||
rm -rf frontend/src/app/settings/
|
||
rm -rf frontend/src/app/watchlist/
|
||
rm -rf frontend/src/app/careers/
|
||
```
|
||
|
||
### Konsolidieren:
|
||
- `/market/page.tsx` und `/auctions/page.tsx` → Eine Seite für Public Market
|
||
- `/intelligence/page.tsx` prüfen ob Redirect noch nötig
|
||
|
||
### Code-Änderungen:
|
||
1. **Market Page (Terminal)**: Pounce Direct + External in einem Feed
|
||
2. **Auctions Page (Public)**: Pounce Direct prominent
|
||
3. **API Client**: `getMarketplaceListings()` Backend anbinden
|
||
4. **Auctions API**: Unified Feed Endpoint
|
||
5. **Pounce Score**: v2.0 mit Market Signals
|
||
|
||
---
|
||
|
||
# 📊 TEIL 2: KONZEPT — Wohin entwickeln wir?
|
||
|
||
## Executive Summary
|
||
|
||
Die aktuelle Market-Page funktioniert technisch, aber sie ist noch nicht "Unicorn-ready".
|
||
Dieses Konzept transformiert sie von einem einfachen Auktions-Aggregator zur **zentralen Domain-Intelligence-Plattform**.
|
||
|
||
---
|
||
|
||
## 📊 IST-Analyse: Aktuelle Implementation
|
||
|
||
### Datenquellen (Backend)
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ CURRENT DATA FLOW │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ ExpiredDomains.net ──┐ │
|
||
│ │ │
|
||
│ GoDaddy RSS Feed ────┼──→ Web Scraper ──→ PostgreSQL/SQLite │
|
||
│ │ (hourly) (domain_auctions) │
|
||
│ Sedo Public Search ──┤ │
|
||
│ │ │
|
||
│ NameJet Public ──────┤ │
|
||
│ │ │
|
||
│ DropCatch Public ────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### Probleme mit dem aktuellen Setup
|
||
|
||
| Problem | Impact | Severity |
|
||
|---------|--------|----------|
|
||
| **Web-Scraping ist fragil** | Seiten ändern Layout → Scraper bricht | 🔴 Hoch |
|
||
| **Daten sind oft veraltet** | End-Zeiten stimmen nicht, Preise falsch | 🔴 Hoch |
|
||
| **Kein "Pounce Direct" Content** | Alles nur externe Daten, kein USP | 🔴 Hoch |
|
||
| **Rate-Limiting & Blocking** | Plattformen blockieren Scraper | 🟡 Mittel |
|
||
| **Keine echte Echtzeit-Daten** | Stündliches Scraping ist zu langsam | 🟡 Mittel |
|
||
| **Pounce Score ist simpel** | Nur Length + TLD, keine echten Signale | 🟡 Mittel |
|
||
|
||
---
|
||
|
||
## 🚀 SOLL-Konzept: Die Unicorn-Architektur
|
||
|
||
### Phase 1: Der "Clean Feed" (Jetzt – 3 Monate)
|
||
|
||
**Ziel:** Die beste Auktions-Übersicht mit echtem Mehrwert.
|
||
|
||
#### 1.1 Daten-Strategie: Hybrid-Ansatz
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ NEW DATA ARCHITECTURE │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ TIER 1: OFFIZIELLE APIs (zuverlässig, real-time) │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ • GoDaddy Partner API (wenn Partner-Account vorhanden) │
|
||
│ • Sedo Partner API (Affiliate-Programm) │
|
||
│ • DropCatch Public API │
|
||
│ │
|
||
│ TIER 2: WEB SCRAPING (Backup, validiert) │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ • ExpiredDomains.net (Deleted Domains) │
|
||
│ • NameJet Public (mit Fallback-Logik) │
|
||
│ │
|
||
│ TIER 3: POUNCE EXCLUSIVE (unser USP!) │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ • User-Listings ("Pounce Direct" / "For Sale") │
|
||
│ • DNS-verifizierte Eigentümer │
|
||
│ • Sofort-Kauf-Option │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
#### 1.2 Der "Clean Feed" Algorithmus
|
||
|
||
```python
|
||
# Spam-Filter v2.0 (Vanity Filter)
|
||
def is_premium_domain(domain: str) -> bool:
|
||
name = domain.rsplit('.', 1)[0]
|
||
tld = domain.rsplit('.', 1)[1]
|
||
|
||
# REGEL 1: Nur Premium-TLDs für Public
|
||
premium_tlds = ['com', 'io', 'ai', 'co', 'de', 'ch', 'net', 'org', 'app', 'dev']
|
||
if tld not in premium_tlds:
|
||
return False
|
||
|
||
# REGEL 2: Keine Spam-Muster
|
||
if len(name) > 12: # Kurz = Premium
|
||
return False
|
||
if name.count('-') > 0: # Keine Bindestriche
|
||
return False
|
||
if sum(c.isdigit() for c in name) > 1: # Max 1 Zahl
|
||
return False
|
||
if any(word in name.lower() for word in ['xxx', 'casino', 'loan', 'cheap']):
|
||
return False
|
||
|
||
# REGEL 3: Konsonanten-Check (kein "xkqzfgh.com")
|
||
consonants = 'bcdfghjklmnpqrstvwxyz'
|
||
max_consonant_streak = max(len(list(g)) for k, g in groupby(name, key=lambda c: c.lower() in consonants) if k)
|
||
if max_consonant_streak > 4:
|
||
return False
|
||
|
||
return True
|
||
```
|
||
|
||
#### 1.3 Pounce Score 2.0
|
||
|
||
Der aktuelle Score ist zu simpel. Hier ist die verbesserte Version:
|
||
|
||
```python
|
||
def calculate_pounce_score_v2(domain: str, auction_data: dict) -> int:
|
||
score = 50 # Baseline
|
||
name = domain.rsplit('.', 1)[0]
|
||
tld = domain.rsplit('.', 1)[1]
|
||
|
||
# ══════════════════════════════════════════════════════════════
|
||
# A) INTRINSIC VALUE (Domain selbst)
|
||
# ══════════════════════════════════════════════════════════════
|
||
|
||
# Länge (kurz = wertvoll)
|
||
length_scores = {1: 50, 2: 45, 3: 40, 4: 30, 5: 20, 6: 15, 7: 10}
|
||
score += length_scores.get(len(name), max(0, 15 - len(name)))
|
||
|
||
# TLD Premium
|
||
tld_scores = {'com': 20, 'ai': 25, 'io': 18, 'co': 12, 'de': 10, 'ch': 10}
|
||
score += tld_scores.get(tld, 0)
|
||
|
||
# Dictionary Word Bonus
|
||
common_words = ['tech', 'data', 'cloud', 'app', 'dev', 'net', 'hub', 'lab', 'pro']
|
||
if name.lower() in common_words or any(word in name.lower() for word in common_words):
|
||
score += 15
|
||
|
||
# ══════════════════════════════════════════════════════════════
|
||
# B) MARKET SIGNALS (Aktivität)
|
||
# ══════════════════════════════════════════════════════════════
|
||
|
||
# Bid Activity (mehr Bids = mehr Interesse)
|
||
bids = auction_data.get('num_bids', 0)
|
||
if bids >= 20: score += 15
|
||
elif bids >= 10: score += 10
|
||
elif bids >= 5: score += 5
|
||
|
||
# Time Pressure (endet bald = Opportunity)
|
||
hours_left = auction_data.get('hours_left', 999)
|
||
if hours_left < 1: score += 10 # HOT!
|
||
elif hours_left < 4: score += 5
|
||
|
||
# Price-to-Value Ratio
|
||
current_bid = auction_data.get('current_bid', 0)
|
||
estimated_value = estimate_base_value(name, tld)
|
||
if current_bid > 0 and estimated_value > current_bid * 1.5:
|
||
score += 15 # Unterbewertet!
|
||
|
||
# ══════════════════════════════════════════════════════════════
|
||
# C) PENALTIES (Abzüge)
|
||
# ══════════════════════════════════════════════════════════════
|
||
|
||
if '-' in name: score -= 30
|
||
if any(c.isdigit() for c in name) and len(name) > 3: score -= 20
|
||
if len(name) > 15: score -= 25
|
||
|
||
return max(0, min(100, score))
|
||
```
|
||
|
||
---
|
||
|
||
### Phase 2: Der "Pounce Direct" Marktplatz (3 – 6 Monate)
|
||
|
||
**Ziel:** Eigenes Inventar = Unique Content = USP
|
||
|
||
#### 2.1 Das Killer-Feature: "Pounce Direct"
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ POUNCE DIRECT INTEGRATION │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ MARKET FEED (Gemischt) │
|
||
│ ═══════════════════════════════════════════════════════════ │
|
||
│ │
|
||
│ ┌───────────────────────────────────────────────────────────┐ │
|
||
│ │ 💎 POUNCE DIRECT │ │
|
||
│ │ ───────────────────────────────────────────────────────── │ │
|
||
│ │ zurich-immo.ch $950 ⚡ INSTANT [BUY] │ │
|
||
│ │ ✅ Verified Owner │ │
|
||
│ └───────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
│ ┌───────────────────────────────────────────────────────────┐ │
|
||
│ │ 🏢 EXTERNAL AUCTION │ │
|
||
│ │ ───────────────────────────────────────────────────────── │ │
|
||
│ │ techflow.io $250 ⏱️ 6h left [BID ↗] │ │
|
||
│ │ via GoDaddy │ │
|
||
│ └───────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
#### 2.2 Warum das genial ist
|
||
|
||
| Vorteil | Erklärung |
|
||
|---------|-----------|
|
||
| **Unique Content** | Domains, die es NUR bei Pounce gibt |
|
||
| **Höhere Conversion** | "Instant Buy" statt "Bid on external site" |
|
||
| **Vendor Lock-in** | Verkäufer listen bei uns (weil 0% Provision) |
|
||
| **SEO Power** | Jede Listing = eigene Landing Page |
|
||
| **Trust Signal** | DNS-Verifizierung = Qualitätsgarantie |
|
||
|
||
#### 2.3 Der Flow für Verkäufer (aus `pounce_terminal.md`)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ LISTING WIZARD │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ STEP 1: DOMAIN EINGEBEN │
|
||
│ ─────────────────────────────────────────────────────────── │
|
||
│ [________________________] zurich-immo.ch │
|
||
│ Preis: [$950] ○ Fixpreis ○ Verhandlungsbasis │
|
||
│ │
|
||
│ STEP 2: DNS VERIFICATION │
|
||
│ ─────────────────────────────────────────────────────────── │
|
||
│ Füge diesen TXT-Record zu deiner Domain hinzu: │
|
||
│ │
|
||
│ Name: _pounce-verify │
|
||
│ Value: pounce-verify-8a3f7b9c2e1d │
|
||
│ │
|
||
│ [🔄 VERIFY DNS] │
|
||
│ │
|
||
│ STEP 3: LIVE! │
|
||
│ ─────────────────────────────────────────────────────────── │
|
||
│ ✅ Domain verifiziert! │
|
||
│ Dein Listing ist jetzt im Market Feed sichtbar. │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
---
|
||
|
||
### Phase 3: Die Daten-Hoheit (6 – 12 Monate) 🏆
|
||
|
||
**Ziel:** Unabhängigkeit von externen Quellen. **EIGENE DATEN = EIGENES MONOPOL.**
|
||
|
||
> *"Pounce weiß Dinge, die GoDaddy dir verheimlicht."* — pounce_strategy.md
|
||
|
||
#### 3.1 Zone File Analysis — Der Unicorn-Treiber
|
||
|
||
**Was sind Zone Files?**
|
||
Zone Files sind die "Master-Listen" aller registrierten Domains pro TLD. Sie werden täglich von den Registries (Verisign, PIR, etc.) aktualisiert.
|
||
|
||
**Wer hat Zugang?**
|
||
- Jeder kann sich bei ICANN-akkreditierten Registries bewerben
|
||
- Verisign (.com/.net): https://www.verisign.com/en_US/channel-resources/domain-registry-products/zone-file/index.xhtml
|
||
- PIR (.org): Zone File Access Program
|
||
- Donuts (.xyz, .online, etc.): TLD Zone File Access
|
||
|
||
**Kosten:** $0 - $10,000/Jahr je nach TLD und Nutzung
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ ZONE FILE PIPELINE — Die Daten-Revolution │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ TIER 1: CRITICAL TLDs (Sofort beantragen) │ │
|
||
│ ├─────────────────────────────────────────────────────────┤ │
|
||
│ │ Verisign → .com, .net ~160M + 13M Domains │ │
|
||
│ │ PIR → .org ~10M Domains │ │
|
||
│ │ Afilias → .info ~4M Domains │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
│ │ │
|
||
│ ▼ │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ TIER 2: PREMIUM TLDs (Phase 2) │ │
|
||
│ ├─────────────────────────────────────────────────────────┤ │
|
||
│ │ CentralNIC → .io, .co Premium für Startups │ │
|
||
│ │ Google → .app, .dev Tech-Domains │ │
|
||
│ │ Donuts → .xyz, .online Volumen │ │
|
||
│ │ SWITCH → .ch Schweizer Markt │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
│ │ │
|
||
│ ▼ │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ POUNCE INTELLIGENCE ENGINE │ │
|
||
│ ├─────────────────────────────────────────────────────────┤ │
|
||
│ │ │ │
|
||
│ │ 1. DAILY DOWNLOAD (4:00 UTC) │ │
|
||
│ │ └─→ ~500GB komprimierte Daten pro Tag │ │
|
||
│ │ │ │
|
||
│ │ 2. DIFF ANALYSIS │ │
|
||
│ │ └─→ Was ist NEU? Was ist WEG? │ │
|
||
│ │ │ │
|
||
│ │ 3. DROP PREDICTION │ │
|
||
│ │ └─→ Domains die aus Zone verschwinden = droppen │ │
|
||
│ │ │ │
|
||
│ │ 4. QUALITY SCORING (Pounce Algorithm) │ │
|
||
│ │ └─→ Nur Premium-Domains durchlassen │ │
|
||
│ │ │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
│ │ │
|
||
│ ▼ │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ OUTPUT: EXKLUSIVE INTELLIGENCE │ │
|
||
│ ├─────────────────────────────────────────────────────────┤ │
|
||
│ │ │ │
|
||
│ │ 🔮 "Drops Tomorrow" — Domains BEVOR sie in Auktionen │ │
|
||
│ │ 📈 "Trending Registrations" — Was wird gerade gehypt │ │
|
||
│ │ ⚠️ "Expiring Premium" — Hochwertige Domains am Ende │ │
|
||
│ │ 🔍 "Pattern Detection" — Welche Keywords explodieren │ │
|
||
│ │ │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
#### 3.2 Der Pounce Algorithm — "No-Bullshit" Filter
|
||
|
||
```python
|
||
# backend/app/services/zone_analyzer.py (NEU ZU BAUEN)
|
||
|
||
class ZoneFileAnalyzer:
|
||
"""
|
||
Analysiert Zone Files und findet Premium-Opportunities.
|
||
|
||
Input: Raw Zone File (Millionen von Domains)
|
||
Output: Gefilterte Premium-Liste (Hunderte)
|
||
"""
|
||
|
||
async def analyze_drops(self, yesterday: set, today: set) -> list:
|
||
"""
|
||
Findet Domains die aus der Zone verschwunden sind.
|
||
Diese Domains droppen in 1-5 Tagen (Redemption Period).
|
||
"""
|
||
dropped = yesterday - today # Set-Differenz
|
||
|
||
premium_drops = []
|
||
for domain in dropped:
|
||
score = self.calculate_pounce_score(domain)
|
||
|
||
# Nur Premium durchlassen
|
||
if score >= 70:
|
||
premium_drops.append({
|
||
"domain": domain,
|
||
"score": score,
|
||
"drop_date": self.estimate_drop_date(domain),
|
||
"estimated_value": self.estimate_value(domain),
|
||
})
|
||
|
||
return sorted(premium_drops, key=lambda x: x['score'], reverse=True)
|
||
|
||
def calculate_pounce_score(self, domain: str) -> int:
|
||
"""
|
||
Der Pounce Algorithm — Qualitätsfilter für Domains.
|
||
|
||
Faktoren:
|
||
- Länge (kurz = wertvoll)
|
||
- TLD (com > io > xyz)
|
||
- Keine Zahlen/Bindestriche
|
||
- Dictionary Word Bonus
|
||
- Historische Daten (wenn verfügbar)
|
||
"""
|
||
name = domain.rsplit('.', 1)[0]
|
||
tld = domain.rsplit('.', 1)[1]
|
||
score = 50 # Baseline
|
||
|
||
# Längen-Score
|
||
length_scores = {1: 50, 2: 45, 3: 40, 4: 30, 5: 20, 6: 15, 7: 10}
|
||
score += length_scores.get(len(name), max(0, 15 - len(name)))
|
||
|
||
# TLD Premium
|
||
tld_scores = {'com': 20, 'ai': 25, 'io': 18, 'co': 12, 'ch': 15, 'de': 10}
|
||
score += tld_scores.get(tld, 0)
|
||
|
||
# Penalties
|
||
if '-' in name: score -= 30
|
||
if any(c.isdigit() for c in name): score -= 20
|
||
if len(name) > 12: score -= 15
|
||
|
||
# Dictionary Word Bonus
|
||
if self.is_dictionary_word(name):
|
||
score += 25
|
||
|
||
return max(0, min(100, score))
|
||
```
|
||
|
||
#### 3.3 Der "Drops Tomorrow" Feed — Tycoon Exclusive
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 🔮 DROPS TOMORROW — Tycoon Exclusive ($29/mo) │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ Diese Domains sind NICHT in Auktionen! │
|
||
│ Du kannst sie beim Registrar direkt registrieren. │
|
||
│ │
|
||
│ ───────────────────────────────────────────────────────────── │
|
||
│ │
|
||
│ Domain TLD Score Est. Value Drops In │
|
||
│ ───────────────────────────────────────────────────────────── │
|
||
│ pixel.com .com 95 $50,000 23h 45m │
|
||
│ swift.io .io 88 $8,000 23h 12m │
|
||
│ quantum.ai .ai 92 $25,000 22h 58m │
|
||
│ nexus.dev .dev 84 $4,500 22h 30m │
|
||
│ fusion.co .co 81 $3,200 21h 15m │
|
||
│ │
|
||
│ ───────────────────────────────────────────────────────────── │
|
||
│ │
|
||
│ 💡 Pro Tip: Setze bei deinem Registrar einen Backorder │
|
||
│ für diese Domains. Wer zuerst kommt... │
|
||
│ │
|
||
│ [🔔 Alert für "pixel.com" setzen] │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
#### 3.4 Warum das ein MONOPOL schafft
|
||
|
||
| Wettbewerber | Datenquelle | Problem |
|
||
|--------------|-------------|---------|
|
||
| **ExpiredDomains.net** | Zone Files | Zeigt ALLES (Spam-Hölle) |
|
||
| **GoDaddy Auctions** | Eigene Daten | Nur GoDaddy-Domains |
|
||
| **Sedo** | User-Listings | Überteuert, wenig Volumen |
|
||
| **Pounce** | Zone Files + **Algorithmus** | **Premium-gefiltert, clean** |
|
||
|
||
**Der Unterschied:**
|
||
- ExpiredDomains zeigt dir 100.000 Domains am Tag. Davon sind 99.990 Müll.
|
||
- Pounce zeigt dir 100 Premium-Domains. Alle sind es wert, angeschaut zu werden.
|
||
|
||
**Das verkauft Abos:**
|
||
> *"Ich zahle $29/Monat, weil Pounce mir 20 Stunden Recherche pro Woche spart."*
|
||
|
||
#### 3.5 Technische Umsetzung — Server-Anforderungen
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ ZONE FILE PROCESSING — Infrastructure │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ SERVER REQUIREMENTS: │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ • Storage: 2TB SSD (Zone Files sind ~500GB/Tag komprimiert) │
|
||
│ • RAM: 64GB+ (für effizientes Set-Diffing) │
|
||
│ • CPU: 16+ Cores (parallele Analyse) │
|
||
│ • Kosten: ~$300-500/Monat (Hetzner/OVH Dedicated) │
|
||
│ │
|
||
│ PROCESSING PIPELINE: │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ 04:00 UTC │ Zone File Download (FTP/HTTPS) │
|
||
│ 04:30 UTC │ Decompression & Parsing │
|
||
│ 05:00 UTC │ Diff Analysis (gestern vs heute) │
|
||
│ 05:30 UTC │ Quality Scoring (Pounce Algorithm) │
|
||
│ 06:00 UTC │ Database Update (PostgreSQL) │
|
||
│ 06:15 UTC │ Alert Matching (Sniper Alerts) │
|
||
│ 06:30 UTC │ User Notifications (Email/SMS) │
|
||
│ │
|
||
│ STORAGE STRATEGY: │
|
||
│ ──────────────────────────────────────────────────────────── │
|
||
│ • Nur Premium-Domains speichern (Score > 50) │
|
||
│ • 90 Tage History für Trend-Analyse │
|
||
│ • Ältere Daten archivieren (S3 Glacier) │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
#### 3.6 Phase 1 vs Phase 3 — Was zuerst?
|
||
|
||
| Phase | Datenquelle | Status |
|
||
|-------|-------------|--------|
|
||
| **Phase 1 (JETZT)** | Web Scraping + Pounce Direct | ✅ Implementiert |
|
||
| **Phase 3 (6-12 Mo)** | Zone Files | 🔜 Geplant |
|
||
|
||
**Warum warten?**
|
||
1. Zone File Access braucht Verträge mit Registries (1-3 Monate)
|
||
2. Infrastruktur-Investition (~$500/Monat Server)
|
||
3. Algorithmus muss getestet werden (False Positives vermeiden)
|
||
|
||
**Was wir JETZT tun:**
|
||
- Scraping + Pounce Direct perfektionieren
|
||
- User-Basis aufbauen (die Zone Files später monetarisiert)
|
||
- Algorithmus entwickeln (funktioniert auch ohne Zone Files)
|
||
|
||
---
|
||
|
||
## 💡 Konkrete Änderungen für die Market Page
|
||
|
||
### Frontend-Änderungen
|
||
|
||
#### 1. Visuelle Hierarchie verbessern
|
||
|
||
```tsx
|
||
// VORHER: Alle Items sehen gleich aus
|
||
<div className="grid">
|
||
{items.map(item => <AuctionCard />)}
|
||
</div>
|
||
|
||
// NACHHER: Pounce Direct hervorheben
|
||
<div className="space-y-3">
|
||
{/* Featured: Pounce Direct (wenn vorhanden) */}
|
||
{pounceDirectItems.length > 0 && (
|
||
<div className="bg-gradient-to-r from-emerald-500/10 to-transparent border border-emerald-500/20 rounded-xl p-1">
|
||
<div className="px-4 py-2 flex items-center gap-2 text-xs font-bold text-emerald-400 uppercase tracking-wider">
|
||
<Diamond className="w-3.5 h-3.5" />
|
||
Pounce Direct — Verified Instant Buy
|
||
</div>
|
||
{pounceDirectItems.map(item => <PounceDirectCard />)}
|
||
</div>
|
||
)}
|
||
|
||
{/* Standard: External Auctions */}
|
||
<div className="space-y-2">
|
||
{externalItems.map(item => <AuctionCard />)}
|
||
</div>
|
||
</div>
|
||
```
|
||
|
||
#### 2. Filter-Presets für User-Journeys
|
||
|
||
```tsx
|
||
// Quick-Filter Buttons basierend auf User-Intent
|
||
const FILTER_PRESETS = {
|
||
'ending-soon': {
|
||
label: '⏱️ Ending Soon',
|
||
filter: { hours_left: { max: 4 } },
|
||
sort: 'time_asc'
|
||
},
|
||
'bargains': {
|
||
label: '💰 Under $100',
|
||
filter: { price: { max: 100 }, score: { min: 60 } },
|
||
sort: 'score_desc'
|
||
},
|
||
'premium': {
|
||
label: '👑 Premium Only',
|
||
filter: { score: { min: 80 }, tld: ['com', 'io', 'ai'] },
|
||
sort: 'price_desc'
|
||
},
|
||
'pounce-only': {
|
||
label: '💎 Pounce Direct',
|
||
filter: { source: 'pounce' },
|
||
sort: 'created_desc'
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 3. "Opportunity Score" statt nur "Pounce Score"
|
||
|
||
```tsx
|
||
// Zeige WARUM ein Domain interessant ist
|
||
function OpportunityIndicators({ item }) {
|
||
const indicators = []
|
||
|
||
if (item.hoursLeft < 2) indicators.push({ icon: '🔥', label: 'Ending soon' })
|
||
if (item.numBids < 3) indicators.push({ icon: '📉', label: 'Low competition' })
|
||
if (item.valueRatio > 2) indicators.push({ icon: '💎', label: 'Undervalued' })
|
||
if (item.isPounce) indicators.push({ icon: '⚡', label: 'Instant buy' })
|
||
|
||
return (
|
||
<div className="flex gap-1">
|
||
{indicators.map(ind => (
|
||
<Tooltip content={ind.label}>
|
||
<span className="text-xs">{ind.icon}</span>
|
||
</Tooltip>
|
||
))}
|
||
</div>
|
||
)
|
||
}
|
||
```
|
||
|
||
### Backend-Änderungen
|
||
|
||
#### 1. Unified Feed API
|
||
|
||
```python
|
||
# NEUER ENDPOINT: /api/v1/market/feed
|
||
@router.get("/feed")
|
||
async def get_market_feed(
|
||
# Filter
|
||
source: Optional[str] = Query(None, enum=['all', 'pounce', 'external']),
|
||
score_min: int = Query(0, ge=0, le=100),
|
||
price_max: Optional[float] = None,
|
||
tld: Optional[List[str]] = Query(None),
|
||
ending_within: Optional[int] = Query(None, description="Hours"),
|
||
|
||
# Sort
|
||
sort_by: str = Query('score', enum=['score', 'price', 'time', 'bids']),
|
||
|
||
# Pagination
|
||
limit: int = Query(30, le=100),
|
||
offset: int = Query(0),
|
||
|
||
# Auth
|
||
current_user: Optional[User] = Depends(get_current_user_optional),
|
||
):
|
||
"""
|
||
Unified market feed combining:
|
||
- Pounce Direct listings (user-listed domains)
|
||
- External auctions (scraped from platforms)
|
||
|
||
For non-authenticated users:
|
||
- Apply vanity filter (premium domains only)
|
||
- Blur "Deal Score" (tease upgrade)
|
||
"""
|
||
|
||
items = []
|
||
|
||
# 1. Get Pounce Direct listings
|
||
pounce_listings = await get_published_listings(db)
|
||
for listing in pounce_listings:
|
||
items.append({
|
||
'type': 'pounce_direct',
|
||
'domain': listing.domain,
|
||
'price': listing.asking_price,
|
||
'source': 'Pounce',
|
||
'status': 'instant',
|
||
'verified': listing.verification_status == 'verified',
|
||
'url': f'/buy/{listing.slug}', # Internal!
|
||
})
|
||
|
||
# 2. Get external auctions
|
||
auctions = await get_active_auctions(db)
|
||
for auction in auctions:
|
||
# Apply vanity filter for non-auth users
|
||
if not current_user and not is_premium_domain(auction.domain):
|
||
continue
|
||
|
||
items.append({
|
||
'type': 'auction',
|
||
'domain': auction.domain,
|
||
'price': auction.current_bid,
|
||
'source': auction.platform,
|
||
'status': 'auction',
|
||
'time_left': format_time_remaining(auction.end_time),
|
||
'url': auction.affiliate_url, # External
|
||
})
|
||
|
||
# 3. Calculate scores
|
||
for item in items:
|
||
item['pounce_score'] = calculate_pounce_score_v2(
|
||
item['domain'],
|
||
item
|
||
)
|
||
|
||
# 4. Sort and paginate
|
||
items = sorted(items, key=lambda x: x['pounce_score'], reverse=True)
|
||
|
||
return {
|
||
'items': items[offset:offset+limit],
|
||
'total': len(items),
|
||
'filters_applied': {...},
|
||
}
|
||
```
|
||
|
||
#### 2. Scraper Verbesserungen
|
||
|
||
```python
|
||
class AuctionScraperService:
|
||
"""
|
||
IMPROVED: Resilient scraping with fallbacks
|
||
"""
|
||
|
||
async def scrape_with_fallback(self, platform: str, db: AsyncSession):
|
||
"""Try multiple methods to get data"""
|
||
|
||
methods = [
|
||
(f'_scrape_{platform.lower()}_api', 'API'), # Best: Official API
|
||
(f'_scrape_{platform.lower()}_rss', 'RSS'), # Good: RSS Feed
|
||
(f'_scrape_{platform.lower()}_html', 'HTML'), # Fallback: HTML Scrape
|
||
]
|
||
|
||
for method_name, method_type in methods:
|
||
method = getattr(self, method_name, None)
|
||
if not method:
|
||
continue
|
||
|
||
try:
|
||
result = await method(db)
|
||
if result['found'] > 0:
|
||
logger.info(f"{platform}: Got {result['found']} via {method_type}")
|
||
return result
|
||
except Exception as e:
|
||
logger.warning(f"{platform} {method_type} failed: {e}")
|
||
continue
|
||
|
||
# All methods failed
|
||
logger.error(f"{platform}: All scrape methods failed")
|
||
return {'found': 0, 'new': 0, 'updated': 0, 'error': 'All methods failed'}
|
||
```
|
||
|
||
---
|
||
|
||
## 📈 Metriken für den Erfolg
|
||
|
||
### KPIs für Phase 1
|
||
|
||
| Metrik | Ziel (3 Monate) | Messung |
|
||
|--------|-----------------|---------|
|
||
| **Daily Active Users (DAU)** | 500 | PostHog |
|
||
| **Conversion Rate (Free → Trader)** | 5% | Stripe |
|
||
| **Domains in Feed** | 1000+ | DB Query |
|
||
| **Avg. Session Duration** | > 3 min | PostHog |
|
||
| **Scrape Success Rate** | > 95% | Logs |
|
||
|
||
### KPIs für Phase 2
|
||
|
||
| Metrik | Ziel (6 Monate) | Messung |
|
||
|--------|-----------------|---------|
|
||
| **Pounce Direct Listings** | 100+ | DB Query |
|
||
| **First Sale via Pounce** | ✅ | Manual |
|
||
| **GMV (Gross Merchandise Value)** | $50,000 | Tracked |
|
||
| **Repeat Sellers** | 20% | DB Query |
|
||
|
||
---
|
||
|
||
## 🛠️ Technische Schulden abbauen
|
||
|
||
### Priorität 1: Scraper Stabilität
|
||
|
||
```python
|
||
# Problem: Scraper bricht bei HTML-Änderungen
|
||
|
||
# Lösung: Defensive Parsing mit Fallbacks
|
||
def parse_domain_from_row(row) -> Optional[str]:
|
||
"""Try multiple selectors to find domain"""
|
||
selectors = [
|
||
'a.domain-name',
|
||
'td.domain a',
|
||
'span[data-domain]',
|
||
'a[href*="domain"]',
|
||
]
|
||
|
||
for selector in selectors:
|
||
elem = row.select_one(selector)
|
||
if elem:
|
||
text = elem.get_text(strip=True)
|
||
if '.' in text and len(text) < 100:
|
||
return text.lower()
|
||
|
||
return None
|
||
```
|
||
|
||
### Priorität 2: Caching Layer
|
||
|
||
```python
|
||
# Problem: Jeder Request macht DB-Abfragen
|
||
|
||
# Lösung: Redis Cache für Feed-Daten
|
||
from redis import asyncio as aioredis
|
||
|
||
async def get_market_feed_cached(filters: dict) -> list:
|
||
cache_key = f"market:feed:{hash(str(filters))}"
|
||
|
||
# Try cache first
|
||
cached = await redis.get(cache_key)
|
||
if cached:
|
||
return json.loads(cached)
|
||
|
||
# Generate fresh data
|
||
data = await generate_market_feed(filters)
|
||
|
||
# Cache for 5 minutes
|
||
await redis.setex(cache_key, 300, json.dumps(data))
|
||
|
||
return data
|
||
```
|
||
|
||
### Priorität 3: Rate Limiting pro User
|
||
|
||
```python
|
||
# Problem: Power User könnten API überlasten
|
||
|
||
# Lösung: Tiered Rate Limits
|
||
RATE_LIMITS = {
|
||
'scout': '50/hour',
|
||
'trader': '200/hour',
|
||
'tycoon': '1000/hour',
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 🎯 Nächste Schritte
|
||
|
||
### ✅ ERLEDIGT (11. Dezember 2025)
|
||
- [x] Pounce Score v2.0 implementieren → `_calculate_pounce_score_v2()` in `auctions.py`
|
||
- [x] Unified `/auctions/feed` API deployen → Live und funktional
|
||
- [x] Pounce Direct Listings im Feed integrieren → Kombiniert mit externen Auktionen
|
||
- [x] "💎 Pounce Direct" Badge und Highlighting → Visuelle Hierarchie implementiert
|
||
- [x] Filter-Presets im Frontend → "Pounce Only", "Verified", Preis-Filter
|
||
- [x] Zone File Access Anleitung → `ZONE_FILE_ACCESS.md` erstellt
|
||
|
||
### Nächste Woche
|
||
- [ ] Erste Pounce Direct Listings erstellen (Testdaten)
|
||
- [ ] Scraper-Fallbacks implementieren
|
||
- [ ] Verisign Zone File Access beantragen
|
||
|
||
### Nächster Monat
|
||
- [ ] Opportunity Indicators im UI
|
||
- [ ] Redis Caching Layer
|
||
- [ ] PIR (.org) Zone File Access
|
||
|
||
---
|
||
|
||
## 💎 Fazit
|
||
|
||
Die Market Page ist das Herzstück von Pounce. Mit diesen Änderungen wird sie:
|
||
|
||
1. **Zuverlässiger** (Scraper-Fallbacks, Caching)
|
||
2. **Wertvoller** (Pounce Direct = Unique Content)
|
||
3. **Stickier** (bessere UX, personalisierte Filter)
|
||
4. **Skalierbarer** (Unicorn-ready Architektur)
|
||
|
||
Der Weg zum Unicorn führt über **Datenhoheit** und **einzigartigen Content**.
|
||
Pounce Direct ist der erste Schritt.
|
||
|
||
---
|
||
|
||
# 🔧 TEIL 3: AKTIONSPLAN — Was tun wir konkret?
|
||
|
||
## Phase A: Cleanup (Heute)
|
||
|
||
### 1. Leere Ordner löschen
|
||
|
||
```bash
|
||
# Diese Ordner sind leer und Legacy vom alten /command Routing
|
||
rm -rf frontend/src/app/dashboard/
|
||
rm -rf frontend/src/app/portfolio/
|
||
rm -rf frontend/src/app/settings/
|
||
rm -rf frontend/src/app/watchlist/
|
||
rm -rf frontend/src/app/careers/
|
||
```
|
||
|
||
### 2. Redundante Seiten prüfen
|
||
|
||
| Seite | Entscheidung |
|
||
|-------|--------------|
|
||
| `/market/page.tsx` | ❌ Entfernen → Redirect zu `/auctions` |
|
||
| `/intelligence/page.tsx` | ⚠️ Prüfen → Redirect zu `/tld-pricing` |
|
||
|
||
---
|
||
|
||
## Phase B: Pounce Direct Integration (Diese Woche)
|
||
|
||
### 1. Backend: Unified Market Feed API
|
||
|
||
**Datei:** `backend/app/api/auctions.py`
|
||
|
||
Neuer Endpoint hinzufügen:
|
||
|
||
```python
|
||
@router.get("/feed")
|
||
async def get_unified_market_feed(
|
||
source: str = Query("all", enum=["all", "pounce", "external"]),
|
||
# ... Filter
|
||
):
|
||
"""
|
||
Unified feed combining:
|
||
- Pounce Direct (user listings)
|
||
- External auctions (scraped)
|
||
"""
|
||
items = []
|
||
|
||
# 1. Pounce Direct Listings
|
||
if source in ["all", "pounce"]:
|
||
listings = await db.execute(
|
||
select(DomainListing)
|
||
.where(DomainListing.status == "active")
|
||
)
|
||
for listing in listings.scalars():
|
||
items.append({
|
||
"type": "pounce_direct",
|
||
"domain": listing.domain,
|
||
"price": listing.asking_price,
|
||
"source": "Pounce",
|
||
"status": "instant",
|
||
"verified": listing.is_verified,
|
||
"url": f"/buy/{listing.slug}",
|
||
})
|
||
|
||
# 2. External Auctions
|
||
if source in ["all", "external"]:
|
||
auctions = await db.execute(
|
||
select(DomainAuction)
|
||
.where(DomainAuction.is_active == True)
|
||
)
|
||
for auction in auctions.scalars():
|
||
items.append({
|
||
"type": "auction",
|
||
"domain": auction.domain,
|
||
"price": auction.current_bid,
|
||
"source": auction.platform,
|
||
"status": "auction",
|
||
"time_left": _format_time_remaining(auction.end_time),
|
||
"url": auction.affiliate_url,
|
||
})
|
||
|
||
return {"items": items, "total": len(items)}
|
||
```
|
||
|
||
### 2. Frontend: API Client erweitern
|
||
|
||
**Datei:** `frontend/src/lib/api.ts`
|
||
|
||
```typescript
|
||
async getMarketFeed(
|
||
source: 'all' | 'pounce' | 'external' = 'all',
|
||
filters?: {
|
||
keyword?: string
|
||
tld?: string
|
||
minPrice?: number
|
||
maxPrice?: number
|
||
}
|
||
) {
|
||
const params = new URLSearchParams({ source })
|
||
if (filters?.keyword) params.append('keyword', filters.keyword)
|
||
if (filters?.tld) params.append('tld', filters.tld)
|
||
if (filters?.minPrice) params.append('min_price', filters.minPrice.toString())
|
||
if (filters?.maxPrice) params.append('max_price', filters.maxPrice.toString())
|
||
|
||
return this.request<{
|
||
items: MarketItem[]
|
||
total: number
|
||
}>(`/auctions/feed?${params.toString()}`)
|
||
}
|
||
```
|
||
|
||
### 3. Frontend: Market Page updaten
|
||
|
||
**Datei:** `frontend/src/app/terminal/market/page.tsx`
|
||
|
||
Änderungen:
|
||
1. `api.getMarketFeed()` statt `api.getAuctions()` aufrufen
|
||
2. Pounce Direct Items visuell hervorheben
|
||
3. "Pounce Exclusive" Filter aktivieren
|
||
|
||
---
|
||
|
||
## Phase C: Public Page Alignment (Nächste Woche)
|
||
|
||
### 1. `/auctions/page.tsx` — Pounce Direct hervorheben
|
||
|
||
```tsx
|
||
// Gruppiere Items
|
||
const pounceItems = items.filter(i => i.type === 'pounce_direct')
|
||
const externalItems = items.filter(i => i.type === 'auction')
|
||
|
||
return (
|
||
<>
|
||
{/* Featured: Pounce Direct */}
|
||
{pounceItems.length > 0 && (
|
||
<section className="mb-8">
|
||
<h2 className="flex items-center gap-2 text-xl font-bold mb-4">
|
||
<Diamond className="text-emerald-400" />
|
||
Pounce Exclusive — Verified Instant Buy
|
||
</h2>
|
||
<div className="grid gap-4">
|
||
{pounceItems.map(item => (
|
||
<PounceDirectCard key={item.domain} item={item} />
|
||
))}
|
||
</div>
|
||
</section>
|
||
)}
|
||
|
||
{/* Standard: External */}
|
||
<section>
|
||
<h2 className="text-xl font-bold mb-4">Active Auctions</h2>
|
||
<MarketTable items={externalItems} />
|
||
</section>
|
||
</>
|
||
)
|
||
```
|
||
|
||
### 2. Konsolidierung
|
||
|
||
| Aktion | Details |
|
||
|--------|---------|
|
||
| `/market/page.tsx` entfernen | Redirect zu `/auctions` |
|
||
| `/auctions/page.tsx` umbenennen | → "Market" in Navigation |
|
||
|
||
---
|
||
|
||
## Phase D: Score & Scraper Verbesserungen (Woche 2-3)
|
||
|
||
### 1. Pounce Score v2.0
|
||
|
||
**Datei:** `backend/app/services/valuation.py`
|
||
|
||
Erweitern um:
|
||
- Bid Activity Score
|
||
- Time Pressure Score
|
||
- Value Ratio Score
|
||
- Platform Trust Score
|
||
|
||
### 2. Scraper Fallbacks
|
||
|
||
**Datei:** `backend/app/services/auction_scraper.py`
|
||
|
||
```python
|
||
async def scrape_with_fallback(self, platform: str, db: AsyncSession):
|
||
methods = [
|
||
(f'_scrape_{platform.lower()}_api', 'API'),
|
||
(f'_scrape_{platform.lower()}_rss', 'RSS'),
|
||
(f'_scrape_{platform.lower()}_html', 'HTML'),
|
||
]
|
||
|
||
for method_name, method_type in methods:
|
||
method = getattr(self, method_name, None)
|
||
if not method:
|
||
continue
|
||
|
||
try:
|
||
result = await method(db)
|
||
if result['found'] > 0:
|
||
return result
|
||
except Exception as e:
|
||
logger.warning(f"{platform} {method_type} failed: {e}")
|
||
|
||
return {'found': 0, 'error': 'All methods failed'}
|
||
```
|
||
|
||
---
|
||
|
||
## Checkliste für den Clean Start
|
||
|
||
### Backend:
|
||
- [ ] Unified Feed Endpoint `/auctions/feed` erstellen
|
||
- [ ] Pounce Score v2.0 in `valuation.py` integrieren
|
||
- [ ] Scraper Fallback-Logik hinzufügen
|
||
|
||
### Frontend:
|
||
- [ ] Leere Ordner löschen
|
||
- [ ] `api.getMarketFeed()` implementieren
|
||
- [ ] Market Page: Pounce Direct Integration
|
||
- [ ] Auctions Page: Visuelle Hierarchie
|
||
- [ ] `/market/page.tsx` zu Redirect machen
|
||
|
||
### Testing:
|
||
- [ ] Listing erstellen → Erscheint im Market Feed?
|
||
- [ ] DNS Verification → Funktioniert?
|
||
- [ ] External Auctions → Werden geladen?
|
||
- [ ] Filter "Pounce Only" → Zeigt nur Listings?
|
||
|
||
---
|
||
|
||
## Visualisierung: Datenfluss
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ MARKET FEED │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
|
||
│ │ LISTINGS │ │ AUCTIONS │ │ SCHEDULER │ │
|
||
│ │ (Pounce) │ │ (External) │ │ (Scrape) │ │
|
||
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
|
||
│ │ │ │ │
|
||
│ │ │ │ │
|
||
│ └───────────────────┴───────────────────┘ │
|
||
│ │ │
|
||
│ ▼ │
|
||
│ ┌──────────────────┐ │
|
||
│ │ /auctions/feed │ │
|
||
│ │ (Unified API) │ │
|
||
│ └────────┬─────────┘ │
|
||
│ │ │
|
||
│ ┌─────────────────┼─────────────────┐ │
|
||
│ ▼ ▼ ▼ │
|
||
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
|
||
│ │ TERMINAL │ │ PUBLIC │ │ ADMIN │ │
|
||
│ │ /market │ │ /auctions │ │ /admin │ │
|
||
│ └────────────┘ └────────────┘ └────────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
# 🚀 TEIL 4: ROADMAP ZUM UNICORN
|
||
|
||
## Die 4 Phasen (aus pounce_strategy.md)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ POUNCE UNICORN ROADMAP │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ PHASE 1: INTELLIGENCE (0-18 Monate) │
|
||
│ ═══════════════════════════════════════════════════════════ │
|
||
│ Ziel: 10.000 User, $1M ARR, Datenhoheit │
|
||
│ │
|
||
│ ✅ Pounce Terminal (Dashboard) │
|
||
│ ✅ TLD Pricing (Market Barometer) │
|
||
│ ✅ Auction Aggregator (Scraping) │
|
||
│ ✅ Watchlist/Monitoring │
|
||
│ ⏳ Pounce Direct (Marketplace) │
|
||
│ 🔜 Zone File Analyse │
|
||
│ │
|
||
│ Status: WIR SIND HIER ◄──────────────────────────────────── │
|
||
│ │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ PHASE 2: LIQUIDITÄT (18-36 Monate) │
|
||
│ ═══════════════════════════════════════════════════════════ │
|
||
│ Ziel: Den Transaktionsfluss übernehmen, $10M ARR │
|
||
│ │
|
||
│ 🔮 Pounce Instant Exchange (Escrow integriert) │
|
||
│ 🔮 "Buy Now" Buttons im Dashboard │
|
||
│ 🔮 5% Transaktionsgebühr (statt 15-20% bei Konkurrenz) │
|
||
│ │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ PHASE 3: FINANZIALISIERUNG (3-5 Jahre) │
|
||
│ ═══════════════════════════════════════════════════════════ │
|
||
│ Ziel: Domains als Asset-Klasse, $50-100M ARR │
|
||
│ │
|
||
│ 🔮 Fractional Ownership (Anteile an Premium-Domains) │
|
||
│ 🔮 Domain-Backed Lending (Kredit gegen Domain) │
|
||
│ 🔮 → Wir werden ein FINTECH │
|
||
│ │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ PHASE 4: IMPERIUM (5+ Jahre) │
|
||
│ ═══════════════════════════════════════════════════════════ │
|
||
│ Ziel: $1 Mrd. Bewertung, "Too big to fail" │
|
||
│ │
|
||
│ 🔮 Pounce Enterprise Sentinel (B2B Brand Protection) │
|
||
│ 🔮 Fortune 500 Kunden (Apple, Tesla, etc.) │
|
||
│ 🔮 KI-gestützte Phishing-Takedowns │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
## Was WIR JETZT tun (Phase 1 perfektionieren)
|
||
|
||
### Priorität 1: Pounce Direct perfektionieren
|
||
- [x] Listing-System gebaut
|
||
- [x] DNS-Verifizierung funktioniert
|
||
- [ ] **Im Market Feed anzeigen** ← NÄCHSTER SCHRITT
|
||
- [ ] Visuelle Hierarchie (💎 Pounce vs 🏢 External)
|
||
|
||
### Priorität 2: Datenqualität verbessern
|
||
- [x] Scraping läuft
|
||
- [ ] Fallback-Logik für Scraper
|
||
- [ ] Pounce Score v2.0
|
||
|
||
### Priorität 3: Zone Files vorbereiten
|
||
- [ ] Verisign Zone File Access beantragen
|
||
- [ ] Algorithmus entwickeln (kann lokal getestet werden)
|
||
- [ ] Server-Infrastruktur planen
|
||
|
||
---
|
||
|
||
## Zusammenfassung: Der Weg zum Unicorn
|
||
|
||
```
|
||
HEUTE 6 MONATE 18+ MONATE
|
||
│ │ │
|
||
▼ ▼ ▼
|
||
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
|
||
│ SCRAPING │ →→→ │ ZONE FILES │ →→→ │ FINTECH │
|
||
│ + POUNCE │ │ ANALYSIS │ │ BÖRSE │
|
||
│ DIRECT │ │ │ │ │
|
||
└─────────────┘ └─────────────┘ └─────────────┘
|
||
│ │ │
|
||
│ │ │
|
||
"Content Filler" "Daten-Monopol" "Asset-Klasse"
|
||
Seite wirkt lebendig Exklusive Intel Domains = Aktien
|
||
```
|
||
|
||
---
|
||
|
||
## 💎 Das Mantra
|
||
|
||
> **"Don't guess. Know."**
|
||
>
|
||
> Phase 1: Intelligence
|
||
>
|
||
> **"Don't just buy. Invest."**
|
||
>
|
||
> Phase 3: Asset Class
|
||
|
||
Der Weg zum Unicorn führt über **Datenhoheit** und **einzigartigen Content**.
|
||
|
||
1. **Heute:** Pounce Direct (User-Listings) = Unique Content
|
||
2. **Morgen:** Zone Files = Exklusive Intelligence
|
||
3. **Übermorgen:** Fintech = Milliarden-Bewertung
|
||
|
||
---
|
||
|
||
**Bereit zum Start?** 🚀
|
||
|
||
Sag mir, womit ich beginnen soll:
|
||
1. **Cleanup** — Leere Ordner löschen
|
||
2. **Backend** — Unified Feed API erstellen
|
||
3. **Frontend** — Market Page mit Pounce Direct
|
||
|