From architect
Estimates cost and effort to switch from one tech stack to another. Helps answer: "Can we migrate later if needed?"
npx claudepluginhub navraj007in/architecture-cowork-plugin --plugin architectThis skill uses the workspace's default tool permissions.
Estimates cost and effort to switch from one tech stack to another. Helps answer: "Can we migrate later if needed?"
Guides Next.js Cache Components and Partial Prerendering (PPR) with cacheComponents enabled. Implements 'use cache', cacheLife(), cacheTag(), revalidateTag(), static/dynamic optimization, and cache debugging.
Guides building MCP servers enabling LLMs to interact with external services via tools. Covers best practices, TypeScript/Node (MCP SDK), Python (FastMCP).
Generates original PNG/PDF visual art via design philosophy manifestos for posters, graphics, and static designs on user request.
Estimates cost and effort to switch from one tech stack to another. Helps answer: "Can we migrate later if needed?"
Use this skill to understand:
Provide source and target stacks:
{
"from_stack": {
"backend": "Node.js",
"database": "MongoDB",
"deployment": "Vercel"
},
"to_stack": {
"backend": "Go",
"database": "PostgreSQL",
"deployment": "Kubernetes"
},
"codebase_size": 50000, // lines of code
"monthly_revenue": 50000,
"max_downtime_hours": 4
}
A migration impact report:
{
"from": "Node.js + MongoDB + Vercel",
"to": "Go + PostgreSQL + Kubernetes",
"feasibility": {
"effort_engineer_weeks": 8,
"cost_dollars": 50000,
"timeline_weeks": 10,
"downtime_hours": 4,
"risk_level": "high"
},
"cost_breakdown": {
"engineering_salaries": 40000, // 8 weeks × 4 engineers
"infrastructure_setup": 3000, // Kubernetes cluster setup
"testing_and_qa": 2000, // Migration testing
"consulting_fees": 5000 // Go/Kubernetes specialists
},
"timeline": {
"week_1_2": "Parallel: Start building Go services, set up Kubernetes",
"week_3_4": "Migrate first microservice (low-risk service)",
"week_5_6": "Migrate core services (with fallback to old system)",
"week_7_8": "Full cutover, run both systems in parallel",
"week_9_10": "Monitor, optimize, fix issues"
},
"payback_period": 8, // months until savings offset cost
"roi": {
"monthly_savings": 2000, // Go scales cheaper than Node at their scale
"annual_savings": 24000,
"breakeven_months": 25 // 50k / 2k per month
},
"risk_assessment": {
"data_loss_risk": 0.02, // 2% chance of data loss
"downtime_risk": 0.05, // 5% chance of >4hr unplanned downtime
"budget_overrun_risk": 0.25, // 25% chance of going 25% over budget
"timeline_overrun_risk": 0.4 // 40% chance of taking 12+ weeks
},
"mitigation_strategies": [
"Run both systems in parallel for 2 weeks (verify data consistency)",
"Implement circuit breakers (if Go service slow, fall back to Node)",
"Canary deployment (route 5% traffic to Go, verify works)",
"Comprehensive test suite (validate data integrity)",
"On-call rotation (engineer available if issues arise)"
],
"can_do_gradual_migration": true,
"gradual_path": [
"Week 1-2: Build Go API for new features only",
"Week 3-4: Route new feature requests to Go, old features to Node",
"Week 5-6: Migrate historical data incrementally (background job)",
"Week 7-8: Route more features to Go (30% traffic)",
"Week 9: Route majority to Go (70% traffic)",
"Week 10+: Retire old Node system once fully stable"
],
"recommendation": "Worth it only if scaling to >1M DAU. Otherwise cost outweighs savings."
}
Example: Node.js → Go (both use PostgreSQL)
Effort: 2-3 engineer weeks
Cost: $10-15k
Downtime: 1-2 hours
Complexity: Low (database schema unchanged)
Steps:
Why easy: Database contract unchanged, can run both simultaneously
Example: Node.js + MongoDB → Go + PostgreSQL
Effort: 6-8 engineer weeks
Cost: $40-50k
Downtime: 2-4 hours
Complexity: Medium (schema mapping needed)
Steps:
Why harder: Must map MongoDB doc structure → PostgreSQL schema (not 1-to-1)
Example: Node.js + MongoDB + Vercel → Go + PostgreSQL + Kubernetes
Effort: 8-12 engineer weeks
Cost: $50-80k
Downtime: 4-8 hours
Complexity: High (infrastructure completely different)
Steps:
Why hard: Three different systems, all must work together correctly
When NOT to migrate:
Example: Live multiplayer game (can't take 4 hours downtime)
Formula:
migration_cost = engineering + infrastructure + consulting + opportunity_cost
annual_savings = current_cost - new_cost
payback_period_months = migration_cost / (annual_savings / 12)
worth_it = payback_period <= 18 months (typical 3-5 year horizon)
Example:
Current: Node.js + Vercel = $8k/month
New: Go + Kubernetes = $4k/month
Savings: $4k/month = $48k/year
Migration cost: $50k
Payback period: 50k / (48k/12) = 12.5 months ✅ Worth it
Running payoff calculation:
Month 0: -$50k (migration)
Month 12: -$50k + (4k × 12) = -$2k (still not paid back)
Month 13: -$50k + (4k × 13) = +$2k ✅ (now profitable)
High risk (10-20%):
Medium risk (3-5%):
Low risk (<2%):
Mitigation: Run both systems simultaneously for 1-2 weeks, verify data matches exactly
Factors:
Typical downtime estimates:
Simple backend swap: 1 hour
Backend + database: 2-4 hours
Everything including infra: 4-8 hours
Mitigation:
Common reasons for overruns:
Strategies to control:
Most migrations take 20-50% longer than estimated:
Realistic timeline:
Buffer to build in: 2-3 weeks (20-30%)
One day, flip switch from old to new system
Pros:
Cons:
Risk level: High
Start routing percentage of traffic to new system, increase over time
Pros:
Cons:
Risk level: Medium
1. Is the migration forced?
a) Yes (old tech no longer supported): DO IT
b) No (voluntary): go to step 2
2. How much will we save annually?
a) <$10k/year: Don't migrate (not worth effort)
b) $10-50k/year: Marginal (do if team capacity allows)
c) $50k+/year: Worth investigating
3. What's the payback period?
a) <12 months: ✅ DO IT (quick ROI)
b) 12-24 months: ⚠️ MAYBE (reasonable if business stable)
c) >24 months: ❌ DON'T (too long to justify)
4. Do we have team capacity?
a) Dedicated team (can pause feature work): ✅ Good
b) Shared capacity (features paused 2 months): ⚠️ Okay
c) No capacity (features continue): ❌ Too risky
5. Can we do gradual migration?
a) Yes (architecture supports parallel): ✅ Much safer
b) No (big bang required): ⚠️ Higher risk
→ Decision:
Forced migration OR (savings > $50k AND payback < 18 months AND team capacity available)
→ DO IT
Anything else: Wait (improve ROI or find different problem to solve)
From: Python → Python + Rust (for file syncing)
Cost: Estimated $5-10M over 2 years
Payoff: 40% reduction in sync latency, better battery life
ROI: Millions per month (core product improvement)
Lesson: Strategic migrations (improve product) have higher ROI than cost migrations
From: Heroku (managed) → AWS (self-managed)
Cost: $100k over 3 months (migration + consulting)
Savings: $500k/year (self-managing cheaper than Heroku premium)
Payback: 2.4 months ✅ (very quick ROI)
Timeline: 3 months (longer than estimated due to DevOps learning curve)
Lesson: Migrations from expensive managed → cheap self-managed always worth it
Problem: Python 2 end-of-life (no security patches)
Migration to: Python 3
Status: Still not done! (4 years overdue)
Cost: Estimated $1-2M to do now (would have been $100k in 2018)
Lesson: Don't delay forced migrations (cost grows exponentially)
/architect:recommend-stack// After recommending Go option:
if user_concerned_about_switching_later:
simulate_swap("Node.js", "Go")
show: "If you scale to 1M DAU and want Go, it costs $50k and 10 weeks"
help user: "Is Node.js cheaper for your growth path?"
/architect:blueprint-variants// For each variant:
if switching_cost_significant:
add_to_report: "Switching from baseline to this option later costs $X"
help_user: "Choose baseline now to keep switching options open"
/architect:simulate-migration/architect:simulate-migration --from node --to go
→ Estimates cost, timeline, risk, ROI of migration
constraint-solver/ — picks initial stack (reduces need to migrate)stack-compatibility/ — helps pick compatible stacks (easier to migrate between)cost-optimizer/ — estimates long-term costs (drives migration decisions)