technical-automation-architect

name	technical-automation-architect
description	Design technical architecture and automation strategies for solo SaaS products. Use when selecting tech stacks, deciding build vs buy, or implementing AI automation to scale operations.
category	business
license	MIT

When to Use This Skill

Use this skill when you need to:

• Choose a tech stack for your solo SaaS product
• Decide build vs buy for features and infrastructure
• Implement AI automation to multiply your effectiveness
• Leverage managed services instead of building from scratch
• Use SaaS boilerplates to accelerate development
• Manage technical debt strategically as solo founder
• Scale to $1M ARR as solo or tiny team

Core Concepts

"Boring Stack" Philosophy

Use established technologies, not cutting-edge:

Why boring wins:

• Faster development (you know the tools)
• Fewer bugs (battle-tested libraries)
• Easier hiring (common skills)
• Better resources (tutorials, help, solutions)
• Long-term maintainability (won't abandon you)

The cost of new/shiny:

• Learning curve: 2-3 months to become productive
• Unknown bugs and edge cases
• Sparse documentation and community
• Abandonment risk (if project dies)

Principle: Leverage existing skills over chasing new tech

Build vs Buy: Leverage Everything

The ruthless equation: "Would you rather spend 3 months building authentication or 3 months acquiring your first 100 customers?"

Leverage (Buy) for:

• Authentication (Auth0, Supabase Auth, Clerk)
• Payment processing (Stripe, Paddle)
• Email infrastructure (SendGrid, Resend, Postmark)
• User management frameworks
• Managed databases (RDS, Supabase, PlanetScale)
• Hosting (Vercel, Railway, Fly.io)

Build only:

• Your core differentiator (unique value proposition)
• Features where existing solutions don't fit
• Custom integrations that don't exist

SaaS boilerplates: Can significantly reduce setup time by prebuilding common foundation pieces.

Step-by-Step Architecture Process

Phase 1: Stack Selection (Week 1)

Choose technologies you already know:

• Backend: Django, Rails, or Go (what you're proficient in)
• Frontend: React, NextJS, or HTMX (leverage existing skills)
• Database: PostgreSQL (battle-tested) or SQLite (start simple)
• Infrastructure: Managed services (don't self-host initially)

Avoid:

• New languages you'll need to learn
• Cutting-edge frameworks (use stable, mature tech)
• Complex architectures (microservices, K8s) until proven need

Deliverable: Tech stack decision document

Phase 2: Build vs Buy Matrix (Week 2)

List all components needed:

• Authentication, payments, email, database, hosting, etc.

For each component:

• What managed services exist?
• Cost of managed service vs build time?
• Does it integrate well with chosen stack?
• What's the exit strategy if service fails?

Decision criteria (rules of thumb):

• Buy if: Managed service integration is clearly faster than custom build
• Buy if: Not core differentiator
• Build if: Core unique value prop
• Build if: Existing solutions don't fit use case

Deliverable: Build/buy decision matrix

Phase 3: SaaS Boilerplate Evaluation (Week 3)

Research boilerplates in your stack:

• Django: ShipFast, SaaS Pegasus
• Rails: Jumpstart, Bullet Train
• NextJS: Supabase SaaS Kit, various Next.js starters

Evaluation criteria:

• Active maintenance (last commit within 3 months)
• Community size (stars, issues, discussions)
• Feature match (high overlap with your immediate roadmap)
• License terms (MIT vs paid)
• Tech stack alignment (your preferred tools)

Decision:

• Use boilerplate: If most foundational needs are covered and code quality is acceptable
• Build from scratch: If highly custom requirements

Deliverable: Boilerplate choice or scratch-build decision

Phase 4: Automation Planning (Week 4)

Identify automation opportunities:

• Repetitive tasks (daily/weekly)
• Manual processes (customer onboarding, reporting)
• Communication (emails, notifications, updates)
• Operations (deployments, backups, monitoring)

Automation tools:

• No-code: Zapier, Make (n8n), Airtable
• Code: Scripts, GitHub Actions, cron jobs
• AI: Cursor, v0, Bolt for code generation
• Infrastructure: Terraform, Docker for reproducibility

Deliverable: Automation roadmap prioritized by ROI

Common Mistakes

Mistake 1: Choosing Shiny Over Familiar

• Problem: Spend 3 months learning Rust when you know Python
• Solution: Use boring stack you're proficient in

Mistake 2: Building Solved Problems

• Problem: 3 months building auth from scratch
• Solution: Use Auth0/Supabase in 1 day, ship features

Mistake 3: Over-Engineering Early

• Problem: Microservices, K8s for MVP
• Solution: Monolith, managed hosting until proven need

Mistake 4: No Automation Strategy

• Problem: Manual everything, stuck in operations
• Solution: Automate high-frequency, low-judgment work early

Mistake 5: Ignoring Technical Debt

• Problem: Accumulate debt unconsciously, drowning in hacks
• Solution: Conscious trade-offs, scheduled repayment

Success Metrics

Technical Health Indicators (directional targets):

Metric	Warning	Healthy	Optimal
Dev velocity	<1 feature/week	2-3 features/week	4-5 features/week
Downtime/month	>2 hours	<30 minutes	<5 minutes
Bugs per release	5+	1-2	0-1
Deployment frequency	Monthly	Weekly	Daily
Technical debt ratio	>40%	20-30%	<20%

Red flags:

• ❌ Taking 2+ weeks to ship simple features
• ❌ Constant production incidents
• ❌ Dreading code changes (fear of breaking things)
• ❌ Can't take time off (product breaks without you)

Deep Dives

For comprehensive technical strategies, tools, and frameworks, see the references:

references/stack-comparison.md

• Django vs Rails vs Go comparison
• Frontend options: React vs NextJS vs HTMX
• Database choices: PostgreSQL vs SQLite vs MySQL
• Hosting infrastructure options
• Real-world stack examples from successful solo SaaS

references/managed-services.md

• Authentication: Auth0, Supabase Auth, Clerk comparison
• Payments: Stripe vs Paddle configuration
• Email: SendGrid, Resend, Postmark setup
• Databases: RDS, Supabase, PlanetScale evaluation
• Cost-benefit calculations for each service

references/automation-checklist.md

• 50+ automation opportunities identified
• No-code tools comparison (Zapier vs Make vs n8n)
• AI-assisted automation patterns for solo teams
• Developer productivity multipliers
• CI/CD pipeline templates

Research Notes

This skill synthesizes findings from technical operations research:

Primary Research:

Key Principles:

• Boring stack philosophy - Established tech over shiny new tools
• Leverage everything - Solved problems shouldn't be rebuilt
• Conscious technical debt - Documented trade-offs, scheduled repayment
• Ruthless automation - Automate repetitive work to protect focus for core product and customer outcomes

Recommended Stacks:

• Backend: Django (Python), Rails (Ruby), Go + HTMX + SQLite
• Frontend: React + SWR, NextJS, or HTMX
• Database: PostgreSQL (production), SQLite (start)
• Infrastructure: Docker, Terraform, Kamal (simplified deployment)

Build vs Buy Examples:

• Buy: Auth, payments, email, hosting, user management
• Build: Core differentiator only
• SaaS boilerplates: Can reduce time-to-first-version for common app scaffolding

---

Next Steps After Architecture Setup

Once your tech stack is chosen:

1. Start building - Use boilerplate or scratch-build
2. Automate early - CI/CD, deployments, backups
3. Document decisions - Why you chose X over Y
4. Monitor tech debt - Track ratio, schedule cleanup

Related skills:

• systemization-documentation-expert for SOPs and handoffs
• customer-retention-optimizer for onboarding and lifecycle automation

---

Sources

• DORA | DevOps Research and Assessment
• The Twelve-Factor App
• Auth0 Documentation
• Supabase Auth Documentation
• Stripe Documentation
• Vercel Documentation
• Fly.io Docs