Carpathian Logo

Building Transparent Domain Parking: A Technical Deep Dive

When we needed domain parking for our unused domains, we really wanted something simple that we had total control over and could also control ads and sponsorships if we needed to.

This post explains how our basic domain parking system works, why we chose simplicity over complexity, and the economics behind it.

What We Actually Built

Our domain parking service is intentionally simple:

  • A Flask server (about 600 lines of Python)
  • SQLite database for caching approved domains (For the SSL)
  • Basic webhook integration for tracking visits
  • Platform credits at $0.01 per 1,000 unique visitors
  • Two HTML templates for basic A/B testing

No complex algorithms, no sophisticated fraud detection, no advanced analytics.

Technical Architecture

The Flask Server

We chose Flask because it's simple and we know it well. The entire parking server is a single Python file that:

  • Serves parking pages for approved domains
  • Tracks visits via webhooks to our main API
  • Validates domains against our approved list
  • Does basic A/B testing between two templates

Database Strategy: SQLite + Webhooks

Instead of a complex database setup, we use SQLite locally and send data to our main backend via webhooks.

Local SQLite stores:

  • List of approved domains (synced every 5 minutes)
  • Basic domain metadata

Webhooks handle:

  • Visit tracking to award credits
  • Integration with our main platform

This keeps the parking server simple and resilient. If our main backend is down, parking pages still work.

Domain Validation

Domains get approved through our main platform. The parking server syncs this list every 5 minutes and validates domains for SSL certificate requests through Caddy.

Revenue Model: The Reality

Here's the honest truth about our revenue model:

We pay users $0.01 per 1,000 unique visitors

How we make this work:

  • We earn about $0.02 per 1,000 visitors from ad networks
  • We pay users half of what we earn ($0.01 per 1,000)
  • The remaining half covers infrastructure and processing costs
  • It's essentially a break-even service

Why we do it anyway:

  • We wanted parking for our own domains
  • It drives users to try our other services
  • Platform credits keep users in our ecosystem
  • It's a service we personally wanted to exist

Platform Credits vs. Cash

We pay in platform credits instead of cash for practical reasons:

  1. Immediate payouts - no minimum thresholds
  2. Simpler accounting - no tax complications
  3. User retention - credits encourage using other services
  4. Lower costs - no payment processing fees

Credits can be used for hosting, services, and yes, even swag in our shop.

What We Track

Our tracking is basic but functional. Per visit we capture:

  • Domain visited
  • Visitor IP address
  • User agent
  • Referrer
  • Timestamp

This gets sent via webhook to our main API for credit calculation, basic analytics, and user notifications.

We don't do complex fraud detection beyond obvious bots. Most of our "bot filtering" is just checking user agents.

Simple A/B Testing

We do basic A/B testing between two templates - a 50/50 random split to see which layout performs better. Not sophisticated, but it gives us useful data.

SSL and Infrastructure

SSL certificates are handled by Caddy with automatic Let's Encrypt integration. When a domain points to our nameservers, Caddy automatically gets a certificate.

The parking server includes a domain validation endpoint that Caddy queries to ensure we only get certificates for approved domains.

Lessons Learned

Keep It Simple

We initially planned complex fraud detection, advanced analytics, and sophisticated revenue optimization. We built none of that.

The simple version works fine. Most traffic is legitimate, and the economics work out at scale.

Webhooks Are Reliable

Using webhooks to send data to our main API works well. Even when our main backend has issues, parking pages stay up and we can process the queued data later.

Transparency Matters

Being honest about our simple setup and break-even economics has built more trust than any marketing would have.

A/B Testing Is Easy

Even basic A/B testing provides useful insights. Small changes in layout can affect performance.

What's Next

We're not planning major changes. The system works, it's stable, and it serves our needs.

Possible future improvements:

  • Better mobile templates
  • Domain-specific customization
  • Integration with more ad networks

But honestly, we're happy with the simple version.

Why Share This?

Most companies would make their domain parking sound more sophisticated than it is. We're sharing the reality because:

  • Transparency builds trust - users should know what they're getting
  • Simple solutions work - you don't need complex systems for everything
  • Break-even services are okay - not everything needs to be a profit center

Our domain parking service proves that simple, honest solutions can work well. If you're curious about any specific implementation details or want to discuss how we solved particular challenges, we'd love to hear from you.