Decision Tracking | Bootspring Docs

Decision Tracking helps you log important development decisions, record their outcomes, and learn from patterns over time.

Overview#

Track decisions to:

Remember context - Why was this decision made?
Record outcomes - Did it work? What happened?
Learn patterns - What decisions lead to success?
Get recommendations - What worked before in similar situations?

How It Works#

Decision Logged     Outcome Recorded     Pattern Learned
───────────────────────────────────────────────────────────
"Use PostgreSQL"  ──▶  "Success"      ──▶  "PostgreSQL works
 for user data"       "Fast queries"       well for user data"
                                           (confidence: 0.85)

Logging Decisions#

Via CLI#

# Log a decision
bootspring decision log "Using Clerk for authentication" \
  --type architecture \
  --reason "Built-in SSO, easy integration, good docs"

# With more detail
bootspring decision log "Switching to connection pooling" \
  --type database \
  --reason "Hitting connection limits in production" \
  --context "50+ concurrent users causing timeouts"

Via API#

const memory = require('bootspring/intelligence/memory');

memory.logDecision({
  decision: 'Using Clerk for authentication',
  type: 'architecture',
  category: 'auth',
  reason: 'Built-in SSO, easy integration, good docs',
  context: 'Need enterprise auth features',
  confidence: 0.8
});

Decision Types#

Type	Description	Examples
`architecture`	System design decisions	Tech stack, patterns
`database`	Data model decisions	Schema, queries
`security`	Security-related	Auth, encryption
`performance`	Optimization choices	Caching, indexes
`ui`	Interface decisions	Components, layout
`dependency`	Library choices	npm packages
`process`	Workflow decisions	Git flow, deployments

Recording Outcomes#

When a Decision Works#

bootspring decision outcome <decision-id> success \
  --notes "Reduced auth issues by 90%"

memory.recordOutcome(decisionId, {
  status: 'success',
  notes: 'Reduced auth issues by 90%',
  metrics: { authErrors: -90, loginTime: -500 }
});

When a Decision Fails#

bootspring decision outcome <decision-id> failure \
  --notes "Performance issues under load"

memory.recordOutcome(decisionId, {
  status: 'failure',
  notes: 'Performance issues under load',
  lesson: 'Need connection pooling for high concurrency'
});

Outcome Statuses#

success - Decision worked as expected
partial - Partially successful, some issues
failure - Decision didn't work out
pending - Still evaluating

Getting Recommendations#

Ask for past decisions that worked:

const recommendation = memory.getRecommendation({
  type: 'database',
  category: 'caching',
  context: 'Need to reduce database load'
});
// {
//   found: true,
//   decision: 'Redis for session caching',
//   outcome: 'success',
//   confidence: 0.9,
//   similar: [...]
// }

bootspring decision recommend --type database --category caching

Impact Scoring#

Decisions are automatically scored by impact:

Level	Score	Description
Critical	5	Major architectural decisions
High	4	Important feature decisions
Medium	3	Standard development choices
Low	2	Minor implementation details
Minimal	1	Trivial decisions

How Impact is Calculated#

impactScore = typeWeight × confidenceScore × outcomeMultiplier

typeWeight - Based on decision type (architecture = 1.5, security = 1.4, etc.)
confidenceScore - Your confidence when making the decision
outcomeMultiplier - Success = 1.2, Failure = 0.8

Viewing Decisions#

Recent Decisions#

bootspring decision list --recent 10

const recent = memory.getRecentDecisions(10);

Pending Outcomes#

bootspring decision pending

const pending = memory.getPendingDecisions();

Decision Statistics#

bootspring decision stats

const stats = memory.getStats();
// {
//   total: 45,
//   byType: { architecture: 12, database: 8, ... },
//   outcomes: { success: 30, failure: 5, pending: 10 },
//   successRate: 0.85
// }

Pattern Learning#

The system learns from your decisions:

const learning = require('bootspring/intelligence/learning');

// Analyze patterns
const patterns = learning.analyze();
// {
//   insights: [
//     { type: 'success_pattern', message: 'PostgreSQL decisions succeed 90%' }
//   ],
//   recommendations: {
//     by_type: {
//       'database': { success_rate: 0.9, recommendation: 'Use PostgreSQL' }
//     }
//   }
// }

// Get anti-patterns to avoid
const antiPatterns = learning.getAntiPatterns();
// [
//   { decision: 'hardcoded_secrets', failure_rate: 1.0, recommendation: 'AVOID' }
// ]

Best Practices#

Log decisions as you make them - Context is freshest immediately
Be specific about reasons - Future you will thank present you
Record outcomes promptly - Don't wait too long to evaluate
Review patterns regularly - Learn from your history
Include metrics when possible - Quantifiable outcomes are more useful

Performance#

Decision tracking uses an append-only strategy for fast writes:

O(1) write performance for logging decisions
O(1) write performance for recording outcomes
Periodic compaction keeps read performance optimal