My phone buzzes at 6:03am.
Subject: “ELITE Domain Alert: telford-plumbers.co.uk - Score: 85/100”
A perfect geographic trade domain. Dropping in 48 hours. Nobody else knows yet.
By 6:30am, I’ve placed the backorder. By 10am, I’ve deployed a complete plumber website on the domain using my trades template. Total time: 4 hours from alert to live website.
£49/month recurring revenue from a domain that was sitting there waiting to be noticed.
This is where boring technology actually wins.
Everyone’s looking at my pretty Astro websites on Twitter. Nobody’s looking at the ugly Django backend that woke up at 6:00am, scanned 10,000 expired domains, scored them against 100+ commercial keyword categories, and emailed me the three ELITE opportunities before I finished my coffee.
The sexy frontend gets the applause. The boring backend makes the money.
In This Issue
- The Pretty Frontend: Astro trades template system - 4-hour deployment that clients actually pay for
- The Ugly Backend: Django domain intelligence - The 6am scanning nobody sees but changes everything
- How They Work Together - Finding telford-plumbers.co.uk and deploying in the same morning
- The Commercial Scorer Algorithm - 100+ keywords, location bonuses, ELITE identification
- The £49k/Year Business Model - Why this beats agency work that charges £3k once
The Pretty Frontend (What Everyone Sees)
My Astro trades template system is beautiful:
- 10 complete pages - Home, Services, About, Gallery, Reviews, Contact, etc.
- PageSpeed Score: 95+/100 - Faster than 95% of competitor sites
- Mobile Score: 100/100 - Perfect mobile experience
- YAML configuration - Change business name, phone, colors without touching code
- 4-hour deployment - From blank to live site faster than agencies quote
This is what gets shared on Twitter. This is what clients see and pay £49/month for.
But here’s what nobody talks about:
How do I know which domains to deploy it on?
That’s where the ugly backend comes in.
The Ugly Backend (What Nobody Sees)
Every morning at 6:00am, while I’m still asleep, a Django Python script wakes up and goes to work:
Domain Intelligence Tasks (Automated):
- Scan thousands of expired domains from drop lists
- Run commercial scoring algorithm against each one
- Check trades keywords: plumber, electrician, builder, roofer, etc.
- Check UK location bonuses: telford, birmingham, manchester, london
- Score domain length (shorter = better)
- Calculate ELITE status (70+ points = email alert)
- Export top domains to Google Sheets
- Send email alerts for immediate action
This isn’t sexy. This isn’t getting applause on social media. This is boring Python code running CRON jobs at dawn.
But this is where I win.
The Commercial Scorer Algorithm
Here’s what my Django backend actually does when it finds “telford-plumbers.co.uk”:
1. Keyword Match Score (0-40 points)
- “plumber” = Trades keyword match (+15 points)
- “plumbing” variants recognised
- Multiple keyword categories available: trades, services, ecommerce, industries
2. Commercial Intent Score (0-30 points)
- Service-based business intent detected (+20 points)
- Local service pattern recognised
- Direct commercial application obvious
3. Length Score (0-15 points)
- 16 characters (root domain)
- Perfect length for memorability (+12 points)
4. Location Bonus (+15 points)
- “telford” = Major UK city match
- Geographic service targeting = ELITE
- Tony’s local market = Perfect fit
5. Multi-Keyword Bonus (+10 points)
- Location + Trade = Multiple categories
- Compound value multiplier
Final Score: 85/100 = ELITE
Email alert sent at 6:03am. Domain backorder placed by 6:30am. Website deployed by 10am.
This is boring technology doing unglamorous work at 6am that compounds daily.
How They Work Together
Here’s the actual workflow:
6:00am - Django Backend Wakes Up:
- Scans yesterday’s domain drop lists
- Runs commercial scorer on 10,000+ domains
- Identifies: telford-plumbers.co.uk (85/100 ELITE)
- Sends email alert to my phone
6:30am - I Place Backorder:
- Check email over coffee
- Review ELITE domain details
- Place backorder with registrar (£10-20)
7:00am - Domain Acquired:
- Backorder successful (no competition)
- Point DNS to Netlify
10:00am - Website Deployed:
- Copy Astro trades template
- Edit config/telford-plumbers.yaml:
- Business: “Telford Plumbers”
- Phone: Get local number
- Services: Emergency plumbing, boiler repairs, bathroom fitting
- Service areas: Telford, Shrewsbury, Wellington
- Colors: Blue theme
- Run
npm run build
- Deploy to Netlify
- Connect custom domain
Total time: 4 hours from email alert to live professional website
Monthly recurring: £49/month
The pretty Astro frontend does the client-facing work. The ugly Django backend found the opportunity before anyone else knew it existed.
Real Examples from My System
Here are actual domains my boring backend has flagged:
ELITE Geographic Trades (70-85 points):
- telford-plumbers.co.uk
- birmingham-electricians.co.uk
- manchester-roofers.co.uk
- london-locksmiths.co.uk
High-Value Services (60-75 points):
- emergency-plumber-london.co.uk
- approved-electricians.co.uk
- local-builders-telford.co.uk
Generic Commercial (65-85 points):
- storage-space-uk.co.uk
- van-hire-birmingham.co.uk
- car-parking-manchester.co.uk
Every single one found by Python code running at 6am. Every single one is a potential £49/month client.
The Django backend doesn’t sleep. It doesn’t take weekends. It doesn’t miss opportunities.
The £49k/Year Business Model
Here’s why this works:
Traditional Agency Model:
- Charge £3,000 upfront for website
- Client pays once
- Hope they come back for updates
- Constantly chasing new clients
My Boring Technology Model:
- Find perfect domain at 6am (automated)
- Deploy trades template in 4 hours
- Charge £49/month recurring
- Client gets hosting, updates, support included
- Never chase payments (Direct Debit)
The Math:
- 100 clients × £49/month = £4,900/month recurring (£58,800/year)
- 200 clients × £49/month = £9,800/month recurring (£117,600/year)
- 1000 clients × £49/month = £49,000/month recurring (£588,000/year)
But here’s the critical difference:
I’m not finding clients. I’m finding domains that ATTRACT clients.
“telford-plumbers.co.uk” ranks immediately for “telford plumbers” in Google (exact match domain advantage). Customers find the website. They see professional site with call tracking. They book service.
The domain does the marketing. The Astro template handles the conversion. The Django backend found the opportunity.
Why Boring Technology Wins Here
Let’s be honest about what’s doing the actual work:
Astro + Tailwind (The Pretty Part):
- Static site generation = Fast, cheap hosting
- Component reusability = 4-hour deployment
- Tailwind CSS = No design complexity
- YAML config = No coding required
Django + Python (The Ugly Part):
- Celery scheduled tasks = 6am automation
- PostgreSQL database = Domain tracking at scale
- Commercial scorer = 100+ keyword intelligence
- Email alerts = Actionable intelligence delivered
- Google Sheets export = Client-ready analysis
Together:
- Django finds the domains worth building on
- Astro builds beautiful sites in 4 hours
- Clients pay £49/month recurring
- System runs mostly automated
The boring stack handles both the glamorous frontend AND the unglamorous backend.
The Competitive Moat Nobody Sees
While everyone’s arguing about React vs Vue, I’m building competitive advantage they don’t even know exists:
They’re optimising:
- Build configurations
- CSS-in-JS libraries
- State management patterns
- Framework performance benchmarks
I’m optimising:
- Domain discovery algorithms
- Commercial scoring accuracy
- Deployment automation velocity
- Recurring revenue infrastructure
They’re building websites. I’m building a domain intelligence engine that FINDS the opportunities to build websites on.
That’s the entire difference.
The pretty Astro frontend is table stakes. Every developer can build nice websites.
The ugly Django backend scanning domains at 6am? That’s where I have zero competition.
Try This Tomorrow
Want to see where boring technology actually creates business value?
Build Two Things:
1. The Pretty Part (Frontend):
- Pick Astro or another static generator
- Build ONE perfect template
- Make it configurable (YAML/JSON)
- Deploy in under 4 hours
- 95+ PageSpeed score
2. The Ugly Part (Backend):
- Pick Django or another proven framework
- Build ONE automated scanner
- Run it daily at 6am
- Email yourself opportunities
- Track results in database
Then connect them:
- Backend finds opportunity
- Frontend deploys solution
- Client pays recurring
- Repeat daily
You’ll know it worked when you wake up to opportunities you didn’t know existed yesterday.
That’s not speed. That’s not velocity. That’s automated business development.
The Revolution Nobody Talks About
Everyone’s focused on making the pretty frontend prettier.
The real advantage is building ugly backends that do unglamorous work while you sleep.
Astro makes beautiful websites. Django finds the opportunities to build them on. Together, they make £49/month recurring revenue on domains nobody else noticed.
The next time someone tells me Django is “legacy”, I’ll show them my 6am email alerts finding ELITE domains before they hit the market.
The next time someone says Astro is “too simple”, I’ll show them a 4-hour deployment that scores 95+ on PageSpeed.
Boring technology wins because it’s reliable enough to trust with the ugly backend work that actually makes money.
The pretty frontend gets the Twitter engagement. The ugly backend gets the Direct Debit notifications.
I’ll take the Direct Debits.
P.S. Next week: The daily checklist that runs my entire business in 27 minutes every morning (including the 6am domain check that found £147k of opportunities this year).
P.P.S. Want the commercial domain scorer algorithm? Reply with “DOMAINS” and I’ll send you the complete scoring system with 100+ keyword categories and the exact ELITE threshold calculations.
Tony Cooper
We Build Stores - Where The Backend Finds What The Frontend Builds
tony.cooper@webuildstores.co.uk
07963 242210