**Needs vs Wants vs Savings — Prioritisation Under Constraint**

Needs vs Wants vs Savings — Prioritisation Under Constraint

A practical guide to financial decision-making in constrained environments (budgets, time, resources).

What Is This?

A framework for distinguishing essential expenses (needs), desirable but non-critical spending (wants), and future-focused allocations (savings). You use this to make intentional trade-offs when resources (money, time, energy) are limited—whether in personal finance, project planning, or robotic/AI system design.

Why use it today?
- Avoid debt or resource starvation in projects.
- Optimize limited budgets (e.g., robotics hardware, cloud credits).
- Build resilience against unexpected costs (e.g., sensor failures, model retraining).

Why It Matters

Constraints are universal. A self-driving car startup with a $50K hardware budget must prioritize needs (sensors, compute) over wants (custom enclosures, premium GPUs). A student building a robot arm must allocate funds to savings (backup parts) before wants (LED strips). Poor prioritization leads to: - Project failure (e.g., running out of money mid-build).
- Technical debt (e.g., hacking together a solution because you overspent on non-essentials).
- Opportunity cost (e.g., missing a grant deadline because you lacked emergency funds).

Core Concepts

1. Needs: The Non-Negotiables

Definition: Expenses required for survival, functionality, or minimum viable output.
Examples in robotics/AI:
- Hardware: Motors, microcontrollers (e.g., Raspberry Pi), power supplies.
- Software: Licenses for critical tools (e.g., ROS, MATLAB).
- Operational: Cloud compute for training models, lab space rental.
- Safety: Emergency stop buttons, shielding for high-voltage components.

Key test: "If I skip this, will the project fail or become unsafe?" If yes, it’s a need.

2. Wants: The "Nice-to-Haves"

Definition: Expenses that improve quality, aesthetics, or convenience but aren’t critical.
Examples:
- Hardware: Custom 3D-printed enclosures, RGB LEDs, premium cables.
- Software: Pro versions of tools (e.g., Unity Pro vs. free tier).
- Operational: Faster shipping, branded merch, conference travel.
- Performance: Upgrading from a $50 to $200 GPU for marginal speed gains.

Key test: "Will this directly improve the core functionality or ROI?" If no, it’s a want.

3. Savings: The Future-Proofing Fund

Definition: Resources set aside for: - Emergencies (e.g., replacing a fried motor, unexpected cloud costs).
- Opportunities (e.g., last-minute hardware discounts, grant matching funds).
- Scaling (e.g., extra sensors for future experiments).

Rule of thumb: Allocate 10–20% of your budget to savings. In robotics/AI, this might mean: - Keeping spare parts (e.g., extra servos, backup SD cards).
- Reserving cloud credits for model retraining.
- Setting aside time for refactoring code (vs. rushing to demo).

4. The 50/30/20 Rule (Adapted for Tech Projects)

A heuristic for balancing needs, wants, and savings: | Category | % of Budget | Example (Robotics Project) | |-----------|------------|-------------------------------------| | Needs | 50% | Motors, sensors, compute, rent | | Wants | 30% | Custom PCB, faster shipping, swag | | Savings | 20% | Backup parts, cloud credits, buffer |

Adjust based on risk:
- High-risk projects (e.g., untried hardware): Increase savings to 30%.
- Low-risk projects (e.g., software-only): Reduce savings to 10%.

5. Opportunity Cost: The Hidden Trade-Off

Every dollar/time unit spent on a want is a dollar/time unit not spent on: - A need (e.g., skipping a critical sensor to buy LEDs).
- Savings (e.g., no backup parts when a motor fails).
- Future flexibility (e.g., locked into a proprietary tool because you overspent early).

Ask: "What am I giving up by choosing this?"

How It Works: The Prioritization Workflow

1. List all expenses (brainstorm everything you might need).

2. Example for a drone project:
   ```

   
   
   • Flight controller ($100)
   • Motors ($200)
   • 3D-printed frame ($50)
   • FPV camera ($80)
   • Custom paint job ($30)
   • Spare propellers ($20)
   • LiPo battery ($60)
   • Backup battery ($60) ```

3. Categorize (Needs/Wants/Savings).

4. Needs: Flight controller, motors, frame, LiPo battery.
5. Wants: FPV camera, custom paint job.

6. Savings: Spare propellers, backup battery.

7. Apply constraints (e.g., $500 budget).

8. Total needs: $410 → Under budget.
9. Add savings: $410 + $80 = $490 → Still under.
10. Add wants: $490 + $110 = $600 → Over budget.

11. Decision: Drop the FPV camera (want) to stay under $500.

12. Re-evaluate wants with the 80/20 rule:

13. "Which 20% of wants give 80% of the value?"

14. Example: The FPV camera adds fun but isn’t critical; the paint job adds zero functionality.

15. Allocate savings first (before wants).

16. Always fund savings before non-essentials.

17. Track and adjust.

18. Use a spreadsheet (e.g., Google Sheets) or tool like YNAB (for personal finance) or Tiller (for projects).

Hands-On / Getting Started

Prerequisites

• A project or budget to prioritize (e.g., robotics build, AI training pipeline).
• Basic spreadsheet skills (Google Sheets/Excel).
• Willingness to make hard trade-offs.

Step-by-Step Example: Prioritizing a Robot Arm Project

Budget: $1,000 Goal: Build a 5-DOF robotic arm for pick-and-place tasks.

1. List all potential expenses

- Servo motors (6x MG996R) - $120
- Arduino Mega - $40
- 3D-printed parts - $150
- Aluminum extrusions - $200
- Gripper mechanism - $80
- Power supply - $50
- Wires/connections - $30
- Custom PCB - $100
- Raspberry Pi (for vision) - $75
- Camera module - $50
- LED strips - $20
- Spare servos (2x) - $40
- Backup SD card - $10
- Shipping - $50
- Contingency (10%) - $100

2. Categorize (Needs/Wants/Savings)

3. Calculate totals

• Needs: $120 + $40 + $150 + $200 + $80 + $50 + $30 + $50 = $720
• Wants: $100 + $75 + $50 + $20 = $245
• Savings: $40 + $10 + $100 = $150
• Total: $720 + $245 + $150 = $1,115 (over budget)

4. Apply constraints

• Cut wants first:
• Drop the Raspberry Pi (use Arduino for basic control) → save $75.
• Drop the camera module → save $50.
• Keep the custom PCB (may save time later) → $100.
• Drop LED strips → save $20.
• New wants total: $100.
• Recheck savings:
• Keep spare servos ($40) and backup SD card ($10).
• Reduce contingency to 5% ($50).
• New savings total: $100.
• Final totals:
• Needs: $720
• Wants: $100
• Savings: $100
• Total: $920 (under $1,000).

5. Final budget

Needs ($720):
- Servos: $120
- Arduino: $40
- 3D parts: $150
- Extrusions: $200
- Gripper: $80
- Power: $50
- Wires: $30
- Shipping: $50

Wants ($100):
- Custom PCB: $100

Savings ($100):
- Spare servos: $40
- Backup SD: $10
- Contingency: $50

Expected Outcome

• A functional robot arm with a buffer for failures.
• No unnecessary spending on non-critical features.
• Room to upgrade later (e.g., add vision with leftover contingency).

Common Pitfalls & Mistakes

1. Misclassifying Wants as Needs

Mistake: Labeling a "want" as a "need" to justify spending.
Example: "I need a $300 GPU for my robot’s vision system" (when a $50 camera would suffice).
Fix:
- Ask: "What’s the minimum viable version of this?" - Use the 5 Whys technique: - "Why do I need this GPU?" → "For real-time object detection." - "Why do I need real-time?" → "To avoid latency in pick-and-place." - "Why is latency critical?" → "Because the demo must impress investors." - Reality check: This is a want, not a need.

2. Ignoring Opportunity Cost

Mistake: Spending on a want without considering what you’re giving up.
Example: Buying a $200 custom enclosure (want) instead of a $50 off-the-shelf one, leaving no budget for spare parts (savings).
Fix:
- For every want, ask: "What else could I do with this money?" - Use a trade-off matrix:

3. Underfunding Savings

Mistake: Treating savings as optional or "leftover" money.
Example: Allocating 0% to savings because "nothing will go wrong." Fix:
- Rule: Always reserve at least 10% for savings.
- Robotics/AI-specific savings:
- Hardware: Spare motors, sensors, cables.
- Software: Cloud credits for model retraining.
- Time: Buffer for debugging (e.g., "This will take 2 weeks" → plan for 3).

4. Over-Optimizing for Wants

Mistake: Spending disproportionately on "cool" features.
Example: A $500 drone with a $200 FPV camera (40% of budget) but no spare propellers.
Fix:
- 80/20 rule: Focus on the 20% of wants that give 80% of the value.
- Prioritize wants that:
- Improve core functionality (e.g., better sensors).
- Reduce future costs (e.g., modular design).
- Enable scalability (e.g., extra GPIO pins).

5. Not Revisiting Priorities

Mistake: Sticking to the initial plan even when circumstances change.
Example: Ordering a $200 motor before realizing you need a $300 motor controller.
Fix:
- Re-evaluate weekly (or after major milestones).
- Ask:
- "Did any needs change?" (e.g., new safety requirements).
- "Did any wants become needs?" (e.g., a tool you thought was optional is now critical).
- "Do I have new savings priorities?" (e.g., a part is backordered).

Best Practices

1. Use the "Must/Should/Could" Framework

A stricter version of Needs/Wants/Savings for technical projects: | Category | Definition | Example | |--------------|----------------------------------------|---------------------------------| | Must | Critical for success | Motors, power supply | | Should | Important but not critical | Better sensors, modular design | | Could | Nice-to-have, low impact | LED strips, custom paint |

Allocate budget in this order:
1. Must (100% funded).
2. Should (only if Must is fully funded).
3. Could (only if Should is fully funded).

2. Implement "Sunk Cost Guardrails"

Problem: You’ve already spent $X on a want, so you keep throwing money at it.
Example: Spending $200 on a custom PCB, then another $100 to fix design flaws, instead of switching to a $50 off-the-shelf solution.
Solution:
- Set a hard limit for wants (e.g., "No more than 20% of budget on wants").
- Ask: "If I were starting today, would I still choose this?" - If no, cut your losses.

3. Automate Tracking

Use tools to monitor spending in real time: - Spreadsheets: Google Sheets/Excel with conditional formatting (e.g., red if over budget).
- Apps:
- YNAB (for personal finance).
- Tiller (for project budgets).
- Airtable (for hardware inventories).
- Example Google Sheets formula:
plaintext =IF(SUM(B2:B10)>$D$1, "OVER BUDGET", "OK") (Where B2:B10 = expenses, D1 = budget limit.)

4. Plan for "Known Unknowns"

Problem: You can’t predict everything, but you can prepare for common risks.
Solution:
- Robotics/AI-specific savings:
- Hardware: Spare parts (motors, sensors, cables).
- Software: Cloud credits for model retraining.
- Time: Buffer for debugging (e.g., "This will take 2 weeks" → plan for 3).
- Example contingency plan:
plaintext If motor fails: - Use spare motor (savings).
- If no spare, reallocate $50 from "wants" (e.g., drop LED strips).

5. Negotiate and Substitute

Problem: A "need" is too expensive.
Solutions:
- Negotiate: Ask suppliers for discounts (e.g., "I’m a student—can I get 10% off?").
- Substitute: Use cheaper alternatives (e.g., Raspberry Pi