"Development is done, so why can't we launch yet?"
The PM asks frustrated. The developer sighs and answers.
"Oh, now we need to test, write documentation, prepare deployment, set up monitoring..."
This is exactly the trap of hidden tasks.
If you compare a project to an iceberg, the visible part is only 30%. The remaining 70% is hidden below the surface.
The Tip of the Iceberg
Looking at actual project task distribution is shocking:
Visible Tasks (30%)
├── Feature Implementation
├── UI Development
└── API Development
Hidden Tasks (70%) 😱
├── Code Review
├── Test Writing
├── Bug Fixes
├── Documentation
├── Deployment Prep
├── Monitoring Setup
├── Performance Optimization
├── Security Check
├── Data Migration
└── Team Meetings
Why Do We Keep Missing Them?
1. Developer's Optimistic Thinking
Developers instinctively think only about coding time.
"Login API? Half a day should be enough!"
But in reality:
# Developer's mind
estimate = {
"coding": 4 # hours
}
# Reality
reality = {
"coding": 4,
"debugging": 2,
"test writing": 2,
"code review": 1,
"documentation": 1,
"deployment": 1,
"bug fixes": 2
}
print(f"Expected: {sum(estimate.values())} hours")
print(f"Actual: {sum(reality.values())} hours")
# Expected: 4 hours
# Actual: 13 hours (3x more!)
2. PM's Lack of Experience
PMs may not know the details of the development process. When they say "login feature", they think of simple ID/PW check, but don't think of session management, security, logging, error handling.
Top 10 Frequently Missed Hidden Tasks
Results from analyzing 100+ projects:
1. Code Review (20-30% of coding time)
Writing PR, waiting for review, addressing feedback... All of this takes time.
2. Test Writing (30-50% of coding time)
Thinking "I'll add tests later", but not deciding when that "later" is causes project delays.
3. Bug Fixes (15-20% of total development)
Think bugs won't happen? No such code exists in this world.
4. Meeting Time
Weekly Meeting Overhead
├── Sprint Planning: 2 hours
├── Daily Standup: 15 min × 5 = 1.25 hours
├── Sprint Review: 1 hour
├── Retrospective: 1 hour
└── Ad-hoc Meetings: 2 hours
Total: 7.25 hours/week!
18% of 40 hours/week is meetings.
5. Documentation
- API docs: "I'll add Swagger later..."
- README: "You can see from the code..."
- Operations manual: "I'll deploy it myself..."
These "later" and "if ~" statements ruin projects.
6. Environment Setup
Works fine locally but not on the server! Docker setup, CI/CD pipeline, environment variables... This alone takes a whole day.
7. Data-Related Tasks
- Test data generation: "Need dummy data like real data"
- Migration: "Existing data to new schema..."
- Backup setup: "Just in case..."
8. Security Tasks
OWASP Top 10 check, vulnerability scan, SSL certificate... Discovering these right before launch is a disaster.
9. Performance Optimization
"Why is it so slow?" Profiling, finding bottlenecks, adding caching, DB index tuning... It never ends.
10. Exception Handling
Only thought about Happy Path, but users use the system in ways you never imagined.
Real Case: Payment System Build
A real story from a startup.
Initial Plan (Only Visible Tasks)
Payment System (40 hours)
├── Payment API Development (16 hours)
├── Payment UI Development (16 hours)
└── PG Integration (8 hours)
"Should be done in a week!"
Actual Work (Including Hidden Tasks)
Payment System (96 hours)
├── Visible Tasks (40 hours)
│ ├── Payment API Development (16 hours)
│ ├── Payment UI Development (16 hours)
│ └── PG Integration (8 hours)
└── Hidden Tasks (56 hours) 😱
├── Security Review (8 hours)
├── PCI DSS Compliance (8 hours)
├── Test Scenario Writing (4 hours)
├── Integration Testing (8 hours)
├── Error Case Handling (6 hours)
├── Logging and Monitoring (4 hours)
├── Documentation (4 hours)
├── Code Review (6 hours)
├── Refund Process (4 hours)
└── Admin Tools (4 hours)
2.4x difference!
Given the nature of payment systems, a lot of time went into security and stability, which no one thought of initially.
How to Find Hidden Tasks
1. Use Checklists
Check this checklist whenever adding a new feature:
## Development Task Checklist
### Core Development
- [ ] Feature Implementation
- [ ] UI Development
- [ ] API Development
### Quality Assurance
- [ ] Unit Tests
- [ ] Integration Tests
- [ ] E2E Tests
- [ ] Code Review
### Documentation
- [ ] API Documentation
- [ ] User Guide
- [ ] Code Comments
- [ ] README Update
### Deployment Prep
- [ ] Environment Setup
- [ ] CI/CD Pipeline
- [ ] Monitoring Setup
- [ ] Rollback Plan
### Security
- [ ] Input Validation
- [ ] Authentication/Authorization
- [ ] Security Scan
- [ ] OWASP Check
### Performance
- [ ] Performance Testing
- [ ] Optimization
- [ ] Caching Strategy
2. Analyze Past Projects
Analyze actual time from previous projects. You'll see patterns.
For example, our team's last 3 projects:
- Project A: Planned 100 hours → Actual 145 hours (45% over)
- Project B: Planned 200 hours → Actual 310 hours (55% over)
- Project C: Planned 50 hours → Actual 72 hours (44% over)
Average 48% over. From now on, multiply expected time by 1.5.
3. Ask Team Members
Ask specifically by role:
- Developer: "What else do you do besides coding?"
- QA: "What's needed to prepare tests?"
- DevOps: "What do you check when deploying?"
You'll get surprisingly many tasks.
Hidden Task Estimation Formula
A formula I created based on my experience:
def estimate_total_time(visible_tasks):
"""
Total time = Visible tasks + Hidden tasks
"""
hidden_multipliers = {
"code_review": 0.2, # 20%
"testing": 0.3, # 30%
"bug_fixes": 0.15, # 15%
"documentation": 0.1, # 10%
"meetings": 0.1, # 10%
"deployment_prep": 0.05, # 5%
"other": 0.1 # 10%
}
hidden_tasks = visible_tasks * sum(hidden_multipliers.values())
total = visible_tasks + hidden_tasks
return {
"visible": visible_tasks,
"hidden": hidden_tasks, # 100% additional
"total": total, # 2x
"safe": total * 1.2 # 20% buffer added
}
# Example
result = estimate_total_time(40)
print(f"Visible tasks: {result['visible']} hours")
print(f"Hidden tasks: {result['hidden']} hours")
print(f"Total expected: {result['total']} hours")
print(f"With safety buffer: {result['safe']} hours")
# Output:
# Visible tasks: 40 hours
# Hidden tasks: 40 hours
# Total expected: 80 hours
# With safety buffer: 96 hours
Rule of thumb: Estimate 2-2.5x visible tasks.
Practical Application Example
Step 1: Define Feature
"User Profile Edit Feature"
Step 2: List Visible Tasks
- API Development: 8 hours
- UI Development: 8 hours
Step 3: Add Hidden Tasks
Go through checklist and add one by one:
User Profile Edit (Total 38 hours)
├── Visible Tasks (16 hours)
│ ├── API Development (8 hours)
│ └── UI Development (8 hours)
└── Hidden Tasks (22 hours)
├── DB Schema Modification (2 hours)
├── Image Upload Processing (3 hours)
├── Input Validation (2 hours)
├── Test Writing (4 hours)
├── Code Review (3 hours)
├── Bug Fixes (3 hours)
├── Documentation Update (1 hour)
├── Cache Invalidation (2 hours)
└── Deployment and Monitoring (2 hours)
It's 2.4x more than initial estimate (16 hours), but this is a realistic schedule.
How to Reduce Hidden Tasks
Can't eliminate completely but can reduce:
- Automation: CI/CD, automated tests, auto-generated docs
- Templates: Code templates, document templates
- Checklists: Standardize recurring tasks
- Pair Programming: Reduce code review time
- TDD: Test and development simultaneously
Conclusion: Honest Planning is the Start of Success
If you don't want to hear "Development is done, so why can't we launch?", include all tasks in the plan from the start.
Ignoring hidden tasks:
- Projects will definitely be delayed
- Team members suffer from overtime
- Quality drops
- You lose trust
Estimate 2x visible tasks. It'll feel excessive at first, but it'll turn out right.
Don't forget: 70% of the project is below the surface.
Want to systematically manage hidden tasks in your project? Check out Plexo.
Top comments (0)