Everyone wants to talk about the sexy frontend.
The React ecosystem with its 47 state management libraries. The TypeScript config that requires a PhD to understand. The build pipeline that needs a dedicated DevOps engineer.
Nobody wants to talk about Django and SQLite.
Because they’re boring. They’ve been around forever. They don’t spark debates on Twitter. They don’t require conference talks to explain.
But they work.
And when you’re running an actual business, “works” beats “exciting” every single time.
The Frontend Stack: Astro + Tailwind
Let me tell you why I chose Astro for client websites:
It’s embarrassingly simple. Write components. Build static HTML. Ship to Netlify. Done. No hydration strategies. No “use client” directives. No wrestling with SSR vs SSG vs ISR.
The performance is automatic. 95+ PageSpeed scores without trying. Because shipping HTML is fast. Shocking, I know.
Tailwind means no CSS surprises. bg-blue-500 does exactly what it says. No mysterious cascade issues. No “why is this div 3px off?” debugging sessions. Just utility classes that work.
Is it the most powerful frontend framework? No.
Does it let me build and deploy professional websites in hours instead of weeks? Yes.
That’s why it wins.
The Backend Stack: Django + SQLite
Now let me tell you about the unsexy part nobody wants to discuss.
Django is old. First release: 2005. Nearly 20 years old. Ancient by JavaScript framework standards, where six months is “legacy”.
SQLite is older. First release: 2000. Older than many developers reading this newsletter.
But here’s what they do:
Django gives me:
- An admin interface that actually works (not some half-baked CRUD generator)
- ORM that handles 95% of queries without raw SQL
- Built-in authentication, sessions, middleware
- Management commands for automation
- 20 years of battle-tested stability
SQLite gives me:
- A single file database (no server to maintain)
- ACID compliance (actual data integrity)
- Transactions that work correctly
- Enough performance for 99% of business applications
- Zero configuration
The result? I run a complete business intelligence platform on a single VPS. No Kubernetes. No microservices. No “distributed systems” complexity.
Just Python and SQL doing unglamorous work.
Why Boring Technology Actually Wins
Here’s what nobody tells you about “modern” frameworks:
The JavaScript ecosystem changes every 6 months. The framework you learn today is “legacy” next year. The build tools you master become deprecated. The patterns you adopt get replaced.
Django and SQLite change every 5 years. And when they do change, it’s backwards-compatible. Code I wrote in 2023 still runs in 2025. Without modifications.
That’s the competitive advantage.
While everyone else is rewriting their stack to keep up with ecosystem churn, I’m building features. While they’re debugging hydration mismatches, I’m shipping to customers.
Boring technology means:
- Less time upgrading dependencies
- Less time fixing breaking changes
- Less time reading migration guides
- More time building actual business value
That compounds over years.
The Secret Weapon: Boring Technology + AI
Here’s what nobody’s connecting yet:
AI models were trained on 20 years of Django code. Every Stack Overflow question. Every Django Girls tutorial. Every open-source project. AI knows Django patterns deeply.
AI models understand SQLite perfectly. Simple schemas. Standard SQL. No exotic database features to explain. Just tables, columns, and relationships.
AI can generate Astro components effortlessly. The component model is straightforward. Props go in, HTML comes out. No complex lifecycle hooks to reason about.
AI composes Tailwind utilities naturally. flex items-center justify-between is readable to both humans and AI. No mysterious CSS classes to interpret.
The result? I work with Claude Code to build features at 40-80x typical development velocity.
Not because I’m exceptional. Because the stack is predictable enough that AI can reason about it correctly.
Modern frameworks move too fast for AI training data. The cutting-edge framework from six months ago isn’t in the training set. The patterns that work today weren’t documented when the model was trained.
Boring technology is extensively documented in training data. Django’s 20-year history means AI has seen every pattern, every edge case, every solution.
That’s the competitive advantage nobody sees coming:
Boring technology + AI = velocity that compounds.
The Actual Stack in Production
Here’s what runs We Build Stores business operations:
Frontend (Astro + Tailwind):
- Marketing website: Astro static site on Netlify
- Client websites: Astro templates configured with YAML
- Blog content: Markdown files in Git
- Total complexity: Minimal
Backend (Django + SQLite):
- SEO intelligence platform
- Client management system
- Financial tracking
- Email automation
- Task scheduling with Celery
- Total servers: One VPS
Does this scale to millions of users? No.
Does it run a profitable consultancy with 8 clients? Yes.
Does it require a DevOps team? No.
Does it let me work from anywhere with just a laptop? Yes.
What This Actually Looks Like
When I need a new feature (with AI):
- Describe the feature to Claude Code
- AI generates Django model + admin + views (2 minutes)
- Review, run migrations (30 seconds)
- Feature is live
When I need a new page (with AI):
- “Build a pricing page with three tiers”
- AI generates Astro component + Tailwind styling (3 minutes)
- Review, adjust, deploy
- Page is live
When I need automation (with AI):
- “Create a weekly report that emails client metrics”
- AI writes management command + Celery schedule (5 minutes)
- Review logic, test once
- Automation runs daily
Total time: Hours instead of days.
The AI isn’t writing perfect code. It’s writing Django code that follows 20-year-old patterns. Astro components that match documented examples. Tailwind utilities that work predictably.
No Docker containers. No CI/CD pipeline. No infrastructure-as-code. Just code that runs, generated in minutes because the stack is learnable.
The Competitive Moat Nobody Sees
While everyone’s focused on technology choices, here’s what actually matters:
They’re asking: “Should we use React or Vue?”
I’m asking: “What business problem are we solving?”
They’re debating: “Client-side or server-side rendering?”
I’m building: Features customers will pay for (with AI assistance).
They’re optimising: Bundle sizes and lighthouse scores.
I’m optimising: Time from idea to deployed feature (leveraging 20 years of Django training data).
The tech stack isn’t the competitive advantage. The velocity is.
Django + SQLite + Astro + Tailwind + AI lets me:
- Build features in hours, not sprints (AI knows these stacks deeply)
- Deploy with confidence (boring = fewer edge cases)
- Maintain with minimal effort (stable patterns, well-documented)
- Scale appropriately (30 clients, not 30 million users)
This is why boring technology wins in the AI era.
When everyone adopts AI coding assistants, who has the advantage?
The developers using frameworks with 20 years of training data.
Not the ones using last week’s framework that AI has never seen.
The Truth Nobody Wants to Hear
You don’t need:
- GraphQL
- Microservices
- Kubernetes
- Server-side rendering
- Edge functions
- Real-time sync
- Distributed caching
For 99% of business applications.
You need:
- A database that doesn’t lose data
- A backend that handles HTTP requests
- A frontend that loads quickly
- Code you can understand in 6 months
Django and SQLite give you that. Astro and Tailwind give you that.
Without the complexity tax.
Try This Instead
Next time you start a project, ask:
“Does this need to be cutting-edge?”
Or can you just:
- Write Python/Django for the backend (AI knows it deeply)
- Use SQLite until you actually need Postgres (AI understands simple schemas)
- Build with Astro for static content (AI generates clean components)
- Style with Tailwind utilities (AI composes utilities naturally)
- Work with AI coding assistants (trained on your stack)
- Deploy to one server
- Ship the feature
You’ll know it worked when AI is generating correct code on the first attempt.
Because boring technology is predictable enough that AI can reason about it correctly.
That’s not boring. That’s strategic.
The pretty Astro frontend gets finished quickly (with AI assistance). The ugly Django backend runs reliably for years (following patterns AI knows deeply).
Together, they let me run an actual business instead of maintaining a technology demonstration.
I’ll take the boring stack that works—especially when AI knows it better than any cutting-edge framework.
P.S. The next time someone tells you Django is “legacy,” remind them: legacy means “extensively documented in AI training data.”
P.P.S. Next week: Why SQLite is probably enough for your business (and when it isn’t).
Tony Cooper
We Build Stores - Where Boring Technology Builds Real Businesses
tony.cooper@webuildstores.co.uk
07963 242210