Agile Development – Release Review Checklist

Agile Development Review Checklist:

Feature Requests

How accurate/useful were feature definitions?

1. Was there too much detail? Too little? How might they be made more useful?
2. Was the feature breakdown process useful?
3. Were there changes to feature definitions during development? If so, were these easy to accommodate?
4. Did the delivered features meet the expectation of the customer/product manager?

Do we feel confident ourselves that the features have been sufficiently exercised/used/tested?
Did all the requested features get implemented?
How accurate were effort estimates? What caused differences between estimated and actual effort?

Development

Was the task-based approach useful?
Was there good visibility of progress during the development? (Both internal and external to development team)
Did everyone understand major milestones in the project, where we were and what was needed next at any given time?
Was implementation ‘as expected’? If not, what kind of things made it easier/harder than expected?
Were there any nasty surprises during the process?

Release

Was it easy to manage the release process?
Are we confident that we fixed everything we wanted to and patched the correct things?
Are we confident we know what is in and not in this release in terms of features & bug-fixes?
How could the process be improved?
Did we manage changes and risk appropriately?

Bugs for Analysis

What’s the real root cause of the bug?
Did we fix the root cause or just provide a workaround? (e.g. adding a check for null is probably a workaround, ensuring the value never can be null is more likely to be a root cause fix)
Did the code changes we made to address the bug make sense? Are they easy to understand?
Are there patterns in the kinds of root causes? (E.g. do we have a lot of issues caused by using strings as keys?)
If there are patterns, are they ones that have already been identified as systemic problems with the codebase?
Was the bug caused by:

1. Work we did on the feature the bug was found in?
2. Work we did on a different feature?
3. Work that was done a long time ago? (i.e. bug was always there but we only just noticed it)
4. Could we have found the bug earlier?
5. Through internal use of the feature?
6. Through unit testing?

Was the bug description helpful in reproducing the issue? Could it have been more useful?
Do we feel the bug backlog was under control during the release process?

–EOF (The Ultimate Computing & Technology Blog) —