Production debugging shouldn’t be chaos. Use this structured 9-step workflow to systematically diagnose and fix issues on your bare-metal instances without guessing or breaking more things.
This guide exists as a tested, machine-readable recipe in the Massed Compute MCP. Deploy with an AI agent instead of following manual steps.
When production breaks, you need a systematic approach—not frantic guessing. This workflow helps you debug issues methodically: freeze the problem scope, reproduce the issue consistently, gather read-only evidence first, test one hypothesis at a time, apply minimal fixes, and verify the solution works.
The key principle: one symptom, one hypothesis, one change. This prevents cascading failures and helps you build a reliable knowledge base for future incidents.
| Component | Purpose | Notes |
|---|---|---|
| Ubuntu 24.04 LTS | Base OS for debugging target | Stable systemd, journalctl logging |
| SSH Access | Remote command execution | Key-based authentication preferred |
| Systemd Services | Service management and logs | journalctl for centralized logging |
| Systematic Workflow | Structured debugging process | Prevents chaos debugging |
| Requirement | Specification | Reason |
|---|---|---|
| CPU Cores | 2+ vCPU | Minimal compute for system analysis |
| Memory | 4+ GB RAM | Buffer for logging and analysis tools |
| OS | Ubuntu 24.04 LTS | Standardized systemd environment |
| Network | SSH connectivity | Remote access to target system |
| Permissions | sudo or root access | System-level debugging capabilities |
Pricing data fetched July 6, 2026. No matching SKU rows found for the specified requirements. Check live pricing for current rates on bare-metal and GPU compute.
Step-by-Step Implementation
Freeze Problem Scope
Define exactly what’s broken before you start investigating. Write a one-sentence symptom description:
SYMPTOM: "User login returns 500 error on POST /api/auth/login"
Include timestamps, affected users, and error patterns. Resist the urge to investigate multiple issues simultaneously.
Reproduce the Issue
Create minimal steps to trigger the problem from a clean state:
# Example reproduction steps
curl -X POST https://app.example.com/api/auth/login \
-H "Content-Type: application/json" \
-d '{"email":"[email protected]","password":"test123"}'
# Expected: 200 OK with JWT token
# Actual: 500 Internal Server Error
Document commit SHA, software versions, and configuration that triggers the issue.
Separate Investigation Layers
Debug one layer at a time to avoid confusion:
- Network: Can you reach the service? (ping, telnet, curl)
- Authentication: Are credentials valid? (API keys, certificates)
- Data: Is the database accessible? (connection, schema, permissions)
- Service: Is the application running? (process status, health checks)
- Configuration: Are settings correct? (environment variables, config files)
Gather Read-Only Evidence
Collect system information without making changes:
# System status systemctl status YOUR_SERVICE journalctl -u YOUR_SERVICE --since today # Resource usage top -n 1 df -h free -m # Network connectivity ss -tulpn | grep :80 curl -I http://localhost:8080/health
Form One Hypothesis
Based on evidence, create exactly one testable theory:
HYPOTHESIS: "Database connection pool exhausted due to leaked connections"
Make it specific and measurable. Avoid compound hypotheses like “database is slow AND memory is low.”
Run Minimal Experiment
Test your hypothesis by changing or inspecting one thing only:
# Example: Check database connection count psql -h localhost -U app_user -d production \ -c "SELECT count(*) FROM pg_stat_activity WHERE datname='production';" # If pool limit is 20 and you see 19+ connections, hypothesis confirmed
Document the experiment and its result before making any fixes.
Apply Minimal Fix
Make the smallest change that addresses the root cause:
# Example: Restart service to reset connection pool sudo systemctl restart YOUR_SERVICE # Or increase pool size in config # DATABASE_POOL_SIZE=30 (was 20)
Avoid shotgun fixes. Change one parameter, then test.
Verify the Solution
Re-run your original reproduction steps:
# Re-test the broken scenario
curl -X POST https://app.example.com/api/auth/login \
-H "Content-Type: application/json" \
-d '{"email":"[email protected]","password":"test123"}'
# Should now return 200 OK
If you have automated tests, run them. Confirm the symptom is resolved.
Document and Record
Create a permanent record with this format:
# Incident: Login 500 errors - 2026-07-06 **Symptom:** User login returns 500 error on POST /api/auth/login **Root Cause:** Database connection pool exhausted (20/20 connections leaked) **Fix:** Restarted service + increased pool size to 30 connections **Prevention:** Add connection pool monitoring alert at 80% utilization
Add this to your project’s troubleshooting documentation or incident log.
Troubleshooting Common Issues
Symptom Not Reproducible
If you can’t consistently reproduce the issue:
- Re-freeze the scope with more specific conditions
- Capture
journalctl -u service-name --since todaylogs during the window when issues occur - Look for timing-dependent or load-dependent factors
Multiple Changes Made at Once
If you accidentally changed multiple things:
- Roll back all changes to the last known good state
- Restart at step 5 (Form One Hypothesis) with a single variable
- Test changes one at a time
Evidence Gathering Takes Too Long
For time-critical production issues:
- Start with the fastest evidence:
systemctl statusand recent logs - Apply obvious fixes first (restart unresponsive services)
- Continue systematic investigation after service restoration
Skip All of This: Deploy with an AI Agent
This guide exists as a tested, machine-readable recipe in the Massed Compute MCP. The agent can walk through the systematic debug workflow, execute read-only evidence gathering, and guide you through hypothesis testing without manual step tracking.
Add this configuration to your MCP settings:
{
"mcpServers": {
"massed-compute": {
"type": "http",
"url": "https://vm.massedcompute.com/api/mcp",
"headers": { "Authorization": "Bearer MC_TOKEN" }
}
}
}
Then say:
The agent matches your request against the systematic debug recipe (tested June 10, 2026), provisions the appropriate VM if needed, walks through evidence gathering commands with proper secret redaction, and guides hypothesis testing. If any step fails, it stops and reports the output before continuing to prevent cascading issues.
Quick Setup Guide
For immediate implementation:
- Create debug template: Copy the 9-step workflow format for your team
- Set up evidence gathering: Prepare standard commands for your stack (systemctl, logs, metrics)
- Practice on non-critical issues: Use the workflow for small bugs to build muscle memory
- Document common patterns: Build a knowledge base of symptom → cause → fix patterns
- Train team members: Ensure everyone knows the “one hypothesis, one change” rule
Frequently Asked Questions
01What if I need to fix the issue immediately and can’t follow the full workflow?
For critical production issues, apply obvious fixes first (restart hung services, clear disk space), then return to systematic investigation after service restoration. Document what you changed so you can verify the actual root cause later.
02How do I handle intermittent issues that don’t reproduce consistently?
Expand your scope definition to include timing and load conditions. Capture continuous logs during problem windows and look for patterns. Consider adding monitoring to catch the issue in real-time rather than relying on reproduction.
03What if my hypothesis is wrong and the fix doesn’t work?
That’s normal and valuable information. Roll back your change, document that this hypothesis was disproven, and form a new hypothesis based on the additional evidence. Each failed hypothesis eliminates possibilities and gets you closer to the real cause.
04How do I safely gather evidence without impacting production performance?
Use read-only commands first: systemctl status, journalctl with time limits, resource monitoring tools. Avoid commands that modify state or consume significant resources. If you need deeper investigation, consider testing on a staging environment that mirrors production.
05Should I debug issues directly on production servers?
For live issues affecting users, yes—but follow the systematic workflow to minimize risk. For issues that can be reproduced elsewhere, use a staging environment that matches production configuration. Always prefer read-only investigation on production systems.











