---
esco_uri: http://data.europa.eu/esco/skill/e207163b-7963-4c3e-9494-7a4bb000211b
esco_label: "estimate duration of work"
relation: optional
onet_soc: 15-1242.00
source: stackexchange
confidence: high
qa_count: 5
generator: gemma3:27b (prompt-designed and spot-checked by Claude)
generated: 2026-07-10
---

# estimate duration of work — Database Administrator

As a Database Administrator, 'estimating duration of work' isn’t about pinpoint accuracy – it’s about managing expectations and preventing fires. Daily tasks requiring estimates range from schema changes ('how long to add this index?') to data migrations ('how long to move this database?'), performance tuning requests ('how long to diagnose slow queries?'), or even disaster recovery testing ('how long will a full restore take?').  Good DBAs don't immediately give an hour count. Instead, they *ask clarifying questions* – what’s the data volume? What are the current system loads? Are there dependencies on other teams? This initial analysis is crucial; a vague '2 days' for a migration can quickly become a nightmare if you haven't accounted for ETL processes or post-migration validation.

## Praxiswissen (Stack Exchange, CC-BY-SA 4.0)

**Programmers frequently face pressure to provide estimates for projects with unclear requirements, existing technical debt, competing priorities, and undefined 'done' criteria, leading to consistently inaccurate predictions.**

Instead of immediately offering an estimate, a professional approach involves buying time to properly analyze the request. This includes clarifying scope, building a component-based model of the work, assigning realistic ranges (not single numbers) to each part, and factoring in all associated tasks like documentation, testing, communication, and existing commitments. Crucially, tracking estimates versus actuals helps refine future predictions and demonstrates accountability.

*Source: [How to respond when you are asked for an estimate?](https://softwareengineering.stackexchange.com/q/648) — answer by Thomas Owens, CC-BY-SA 4.0*

**The questioner has consistently inaccurate time-based estimates for projects and is exploring whether story points offer a more reliable approach to gauging task effort.**

Story point estimation focuses on *relative* sizing, comparing tasks to each other rather than attempting precise hour predictions. This method accounts for inherent uncertainties like complexity, required effort, and unknowns—factors that frequently derail time-based estimates. By considering these variables collectively, story points provide a more holistic assessment of task size and facilitate clearer communication about the reasons behind estimations.

*Source: [Why use story points instead of hours for estimating?](https://pm.stackexchange.com/q/2765) — answer by Eric Willeke, CC-BY-SA 4.0*

**The questioner wonders why agile teams use abstract story points for estimating work instead of concrete time-based estimates like 'man days', given the added complexity and difficulty explaining them to stakeholders.**

Estimating in absolute time is unreliable because software development isn't linear; unexpected complexities often dominate. Story points shift the focus from precise timing to *relative* effort, which developers are better at judging. This relative approach reduces pressure to game the system (like padding estimates) and allows teams to empirically determine their velocity over time.

*Source: [Why do we use story points instead of man days when estimating user stories?](https://softwareengineering.stackexchange.com/q/182057) — answer by Erik Dietrich, CC-BY-SA 4.0*

**A developer was asked to sign a contract locking in their initial time estimates for tasks on a project with evolving requirements and new technologies, despite the likelihood of those estimates becoming inaccurate as the scope changed.**

Demanding signed commitments for software development timelines is a major warning sign about a manager's approach; it prioritizes appearances over realistic planning and acknowledges neither inherent uncertainty nor changing circumstances. Effective estimation isn’t about rigid prediction but continuous learning through tracking actual performance against initial guesses, then refining those guesses based on real-world feedback. A healthy environment encourages open communication about evolving estimates rather than punishing developers for unavoidable changes.

*Source: [Project Manager that wants to lock in time estimate with a signed contract](https://softwareengineering.stackexchange.com/q/37600) — answer by Tangurena, CC-BY-SA 4.0*

**The questioner points out that adhering to the DRY principle (avoiding code duplication) can make software tasks harder to estimate and manage, as abstraction requires more research and decision-making compared to simply copying existing code. They ask how to balance DRY with project management needs.**

Effective project management isn't about generating precise estimates; it’s about maximizing value delivery for the customer. Prioritizing predictability over quality or efficiency is counterproductive, as manual repetition introduces more errors and long-term maintenance costs than the initial uncertainty of abstraction. A good PM focuses on delivering a *quality* product quickly and affordably, acknowledging that software estimation is inherently difficult and should not be achieved through artificial means like busywork.

*Source: [Is DRY the enemy of software project management?](https://softwareengineering.stackexchange.com/q/328512) — answer by JacquesB, CC-BY-SA 4.0*

## Weitere Anreicherung

Stage-2 source for future practitioner grounding: arXiv cs.SE (software-engineering preprints).
