Sprint burndown calculator
With 80 points committed, 32 done and 6 days left, the team needs 8 story points per remaining day to finish the 48 still open. Compare that pace with what the team really delivers. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total story points
- 80
- Days elapsed
- 4
- Days remaining
- 6
- Points completed
- 32
- Points remaining
- 48
- Required daily velocity
- 8
This sprint burndown calculator turns the current state of an iteration into one practical planning number: the story points that must be completed per remaining day to finish on time. Enter the original sprint commitment, elapsed days, remaining days, and completed points. The result shows both the unfinished workload and the required daily velocity, making it easy to compare the recovery pace with what the team can realistically deliver before the sprint ends.
Turn a burndown snapshot into a clear daily target
A burndown chart shows direction, but a chart alone does not always answer the question a team faces during a daily review: how quickly must the remaining work move now? This calculator starts with the sprint's total story points and subtracts the points already completed. It then divides that unfinished amount by the number of days still available.
The resulting required daily velocity is a forward-looking target, expressed in story points per remaining day. For example, a sprint with substantial work left and only a few days available will produce a high target immediately, without relying on visual interpretation of a trend line. Include every elapsed day in the elapsed-days field, even when no points were finished, so the snapshot remains an honest description of the calendar.
The elapsed value is returned for context, while the deadline calculation uses the remaining days because those are the opportunities the team still has to complete work. Use the number as a planning signal, not as an individual productivity quota.
Interpret required velocity with delivery context
The required daily velocity tells you the arithmetic pace needed to burn the remaining estimate by the deadline. Compare it with the team's typical completed story points per day, recent throughput, current work in progress, and known impediments. If the target is comfortably below a sustainable pace, the sprint remains arithmetically achievable.
If it is far above that pace, the useful response is not to pressure people to inflate output. Instead, examine whether a blocked item can be unblocked, whether stories can be split while preserving valuable outcomes, or whether scope should be renegotiated with the product owner. A result of zero means all committed points are already complete, so no further daily velocity is required.
Fractional results are normal: they represent an average over the days remaining, not a demand to complete part of a story every day. Story points are team-relative estimates, so the figure should only be compared with evidence from the same team and estimation practice rather than with another team's velocity.
Use consistent inputs and handle the deadline boundary
Keep the units consistent across every input. Total and completed work must both use story points from the same sprint baseline, while elapsed and remaining time should both use the same definition of a day, usually planned working days rather than calendar days. Update completed points according to the team's shared definition of done; counting partially finished work makes the remaining estimate look smaller without creating a deliverable increment.
The calculator rejects completed points above the original total because that combination cannot describe remaining work against the supplied commitment. It also rejects negative values, non-finite numbers, and fractional day counts. Most importantly, zero remaining days is an error: once no days remain, division cannot produce a meaningful required daily pace.
At that boundary, review the sprint outcome directly instead of treating an infinite or undefined number as guidance.
What you can do with it
Prepare for the daily scrum
Calculate the pace needed from today onward and bring a concrete delivery-risk signal to the team's discussion.
Evaluate a scope adjustment
Recalculate after removing or splitting work to see whether the revised remaining commitment matches a sustainable team pace.
FAQ
What does required daily velocity mean?
It is the remaining story points divided by the remaining sprint days: the average number of points that must reach done each day to complete the supplied commitment on time.
Why are days elapsed required if the formula uses days remaining?
Elapsed days preserve the complete sprint snapshot in the output and help users confirm that the timeline they entered is internally understandable. The forward-looking pace itself depends on opportunities still available.
What happens when no days remain?
The calculation returns an invalid-input error because dividing remaining work across zero days cannot produce a meaningful daily velocity.
Can completed points exceed the original sprint total?
No. The calculator rejects that input because remaining work is measured against the supplied total commitment. Use an updated total if scope was formally added.
What should I do if the required daily velocity is too high?
Do not pressure people to inflate output. Check whether a blocked item can be unblocked, whether stories can be split while keeping their value, or whether scope should be renegotiated with the product owner.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/biz/burndown-remaining-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_story_points":80,"days_elapsed":4,"days_remaining":6,"points_completed":32}'const res = await fetch("https://api.kit.forhosting.com/biz/burndown-remaining-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_story_points": 80,
"days_elapsed": 4,
"days_remaining": 6,
"points_completed": 32
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/biz/burndown-remaining-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_story_points": 80,
"days_elapsed": 4,
"days_remaining": 6,
"points_completed": 32
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/biz/burndown-remaining-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_story_points":80,"days_elapsed":4,"days_remaining":6,"points_completed":32}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_story_points":80,"days_elapsed":4,"days_remaining":6,"points_completed":32}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/biz/burndown-remaining-estimate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"total_story_points": 80,
"days_elapsed": 4,
"days_remaining": 6,
"points_completed": 32
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "biz.burndown_remaining_estimate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Use consistent inputs and handle the deadline boundary
Each call costs $0.002, while the same deterministic calculation can run in the browser without network access.
Integration use cases
Add a burndown signal to reporting
Use the deterministic API result in a sprint dashboard, status report, or automated delivery-risk check.
Technical questions
How much does the API request cost?
Each API request costs $0.002. The browser calculation uses the same deterministic logic and can run locally.