TL;DR: I deployed 44 live websites in a single 10-minute session using a single PowerShell script. Zero manual clicks. Zero dashboard logins. This is how you operate 1,000+ domains as a solo founder without losing your mind.
Most solo founders hit a wall around product three or four. They talk about building. They don't talk about what happens when you're managing infrastructure for hundreds of live products at once.
I own 1,000+ premium .app domains, all listed through my domain portfolio & sales overview. Every single one needs to be a live landing page. Every one needs its own deployment, DNS configuration, security headers, sitemap, robots.txt file, and SSL certificate. Do that manually and you're staring at weeks of clicking through GoDaddy dashboards, copy-pasting DNS records one domain at a time, waiting for propagation, verifying each one individually.
That's not a workflow. That's a trap.
So I built a pipeline that turns all of it into one command.
The Three-Tool Stack That Makes This Possible
GitHub serves as the single source of truth. One monorepo. One subfolder per domain. Every domain folder contains exactly 11 files: the HTML landing page, hero image, Open Graph image, sitemap, robots.txt, manifest, favicons. Push to GitHub and everything downstream updates automatically.
Vercel CLI handles all deployments. Not the web dashboard. The command-line interface. Every subfolder becomes its own independent Vercel project. Each deployment takes about 6 seconds. The custom domain gets attached automatically in the same command.
GoDaddy API manages DNS records. Instead of logging into GoDaddy's dashboard and editing A records one by one, PowerShell calls the REST API directly and writes the record instantly. No forms. No waiting for pages to load.
One script coordinates all three. That's the entire deployment pipeline.
The Monorepo Structure
Here's what the repo looks like:
plaintext
visionvix-domains/
├── deploy.ps1 ← one script runs everything
├── domains.txt ← one domain per line
│
├── accessibilityaudit.app/
│ ├── index.html
│ ├── og.jpg
│ ├── hero.webp
│ ├── sitemap.xml
│ ├── robots.txt
│ └── manifest.json
│
├── accountingassistant.app/
│ └── ... same 11 files
│
└── ... one folder per domain
Simple. Consistent. Scalable. Every domain folder is identical in structure. The only thing that changes is the content inside index.html. Each landing page is customized for its specific AI tool or service, but the file structure never varies.
The entire repo is public on GitHub. That's intentional. It's a marketing asset as much as a technical one. Any developer who finds the repo can see the scale immediately: hundreds of domain folders, all consistently structured, all live. It shows what's possible as a solo founder operating with the right tools.
The Script That Does Everything
Here's the core deployment loop. Three API calls. One iteration. Zero manual steps.
On Windows, the deployment script looks like this:
`powershell$domains = Get-Content .\domains.txt
foreach ($domain in $domains) {
$slug = $domain -replace '.app$', ''
# Step 1: Deploy to Vercel (takes ~6 seconds per domain)
vercel deploy .\$domain --prod --yes --name $slug
# Step 2: Attach the custom domain and www subdomain
vercel domains add $domain $slug
vercel domains add www.$domain $slug
# Step 3: Write the A record to GoDaddy via REST API
Invoke-RestMethod -Method Put
-Uri "https://api.godaddy.com/v1/domains/$domain/records/A/@"
-Headers $headers `
-Body '[{"data":"76.76.21.21","ttl":600}]'
# Step 4: Verify DNS was written correctly
$rec = Invoke-RestMethod -Method Get
-Uri "https://api.godaddy.com/v1/domains/$domain/records/A/@"
-Headers $headers
Write-Host "✓ DNS configured: $($rec.data)"
}
That's it. Every domain in the domains.txt file goes through all four steps automatically, one after another.
The $headers variable contains the GoDaddy API key and secret, stored in Windows environment variables. They're set once at the system level, available to every PowerShell session, never written to any file, never pushed to GitHub.
The Vercel A Record
The IP address 76.76.21.21 is Vercel's production A record. Every domain points there. Vercel's edge network handles routing to the correct project based on the domain name. The TTL is set to 600 seconds (10 minutes), which is low enough to make changes quickly if needed but high enough to avoid excessive DNS queries.
Why the CLI Instead of the Dashboard
The Vercel web dashboard works great for one or two projects. It completely breaks down at scale. Clicking through forms, waiting for pages to load, copying project URLs, manually adding domains. That's dozens of clicks per domain, which is exactly the kind of inefficiency solved by top workflow automation tools for small teams.
The CLI turns all of that into one command per domain. vercel deploy pushes the code, builds it, and returns a production URL. vercel domains add attaches the custom domain. Both commands are fully scriptable. That's what makes automation possible.
The Numbers After 44 Deployments
The first run was 5 domains. Then 38 more. Then the full 44 batch, all live, all verified, all returning HTTP 200.
44 domains deployed in a single session. 6 seconds average deploy time per domain. 0 manual clicks required. 100% success rate.
| Metric | Result |
|---|---|
| Domains deployed in first session | 44 |
| Average deploy time per domain | ~6 seconds |
| Manual clicks required | 0 |
| DNS propagation time | 5-30 minutes |
| Total time from script to live | Under 10 minutes |
| HTTP 200 success rate | 100% |
When I ran the verification loop at the end, checking every domain for a 200 status code, every single one came back green. No failures. No retries. No manual fixes.
Security Headers Built Into Every Domain
Every domain automatically gets a full set of security headers via a vercel.json file that lives inside each domain folder. No extra deployment steps. No separate configuration, and can be validated with a website security audit tool. The headers deploy with the site.
Here's what every domain gets out of the box:
json
{
"headers": [
{
"source": "/(.*)",
"headers": [
{
"key": "Content-Security-Policy",
"value": "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';"
},
{
"key": "Strict-Transport-Security",
"value": "max-age=63072000; includeSubDomains; preload"
},
{
"key": "X-Frame-Options",
"value": "DENY"
},
{
"key": "X-Content-Type-Options",
"value": "nosniff"
},
{
"key": "Referrer-Policy",
"value": "strict-origin-when-cross-origin"
},
{
"key": "Permissions-Policy",
"value": "camera=(), microphone=(), geolocation=(), payment=()"
}
]
}
]
}
Content-Security-Policy blocks malicious scripts and injection attacks. Strict-Transport-Security forces HTTPS for 2 years and covers all subdomains. X-Frame-Options: DENY prevents clickjacking. X-Content-Type-Options stops MIME type sniffing. Referrer-Policy controls how much referrer data leaks. Permissions-Policy disables camera, microphone, geolocation, and payment APIs.
Static assets like images and fonts are cached for a full year. The HTML is never cached, so users always get the latest version instantly.
Why These Architecture Decisions Matter
Why a Public GitHub Monorepo?
Security is handled without secrets ever touching the repo. GoDaddy API keys live in Windows environment variables only. Set once at the system level. Available to every PowerShell session. Never written to any file. Never pushed to GitHub.
The repo itself is public because it's a marketing asset. Developers who find it see the scale immediately. Hundreds of domain folders. All consistently structured. All live. It shows what's possible as a solo founder with the right automation in place.
Why Vercel Over the Alternatives?
The CLI is fully scriptable. That's the only reason that matters at this scale. Netlify and Cloudflare Pages both have solid products, but Vercel's CLI lets you deploy a subfolder, attach a domain, and get a production URL in a single command. That's what makes automation possible.
I can run the same script on 5 domains or 500 domains. The process doesn't change. The complexity doesn't increase.
Why GoDaddy API Instead of Manual DNS?
There is no "manual" at 600 domains. Logging into GoDaddy's dashboard and editing A records one by one would take days. The GoDaddy REST API accepts a PUT request with the new A record value and applies it instantly. PowerShell's Invoke-RestMethod makes the call in one line. The entire DNS step takes under a second per domain.
For readers who want to dive deeper into the strategy behind premium .app domains, I covered the positioning and branding implications in my earlier post on AI domain strategy.
What's Next: 1,000 Domains by Next Week
44 domains is the proof of concept. The pipeline works. Now it's just execution at scale.
The plan for the next 7 days:
- Deploy the remaining 950+ domains using the same script
- Index all pages with Google Search Console via sitemap submission
- Track success rates for deployment, DNS propagation, and indexing
- Monitor performance across the entire domain portfolio
- Iterate on the landing page template based on traffic patterns
The script doesn't care if it's running on 50 domains or 500. The time per domain stays constant. The manual effort stays at zero.
The Bigger Point
This isn't really about domains. It's about treating infrastructure as code. One person can operate at enterprise scale when every manual process is replaced with an API call.
The traditional approach to scaling infrastructure is to hire people. You need someone to manage DNS. Someone to handle deployments. Someone to configure security. Someone to monitor uptime.
The alternative is to script everything once and run it a thousand times.
I'm not managing 1,000 domains. I'm managing one script that manages 1,000 domains. That's the difference between a job and a system.
📦 Publishing Kit — Dev.to
Title Options (5)
Selected: I Deployed 44 Live Websites in 10 Minutes With One PowerShell Script (Here's How)
Alternates:
- How I Deploy 1,000+ Premium Domains as a Solo Founder Without Losing My Mind
- Zero-Click Deployment Pipeline: Managing Hundreds of Live Domains With GitHub, Vercel & GoDaddy API
- From Manual Hell to One-Command Deploy: Automating 1,000+ Domain Infrastructure
- The Three-Tool Stack That Let Me Deploy 44 Websites in a Single 10-Minute Session
Slug
i-deployed-44-live-websites-in-10-minutes-with-one-powershell-script
Tags
devops, automation, productivity, domains
