메뉴
Estimates cost and effort to switch from one tech stack to another
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/navraj007in/architecture-cowork-plugin --skill stack-swap-simulator명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
Identifies missing prerequisites (blockers) for each /architect: command based on _state.json field requirements
Tracks actual infrastructure costs against estimated costs and alerts when spend drifts from projection
Defines when and how commands must log architecture decisions to _state.json decisions[] for auditability
SKILL.md 표시 중
| name | stack-swap-simulator |
| description | Estimates cost and effort to switch from one tech stack to another |
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"
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)