Exploring our collective process for full software lifecycle
It’s rather a tall order, all this collaborative working that we do. We all have features we’d like to see. We all have ideas that we’d like to see implemented. But between having an idea and seeing it on OFN there lies a long journey. How can we do this collaboratively, yet efficiently and viably?
Stage One: Idea Sharing
This is done through discourse. If there is a feature anyone in the community would like to see, they are free to add it to discourse and tag people (see below) to comment on the feature.
Try to make comments constructive and useful. Talk in as much detail and specificity as you can about what you’d like the feature to do. Talk about the specific requests of users and the problem this feature is trying to solve. If you don’t feel confident speaking in a technical language, don’t. Just use language that is as clear as possible. Include images, screenshots, diagrams, wireframes, anything you can to make your descriptions as clear as you can.
Be clear if there are parts of your description that are ‘nice to have’ and parts that are ‘must haves’. If you couldn’t use the feature at all without a specific functionality, be clear about this. This will help the technical team in working out the MVP.
People who would like to be tagged to comment on the process of new feature development…
Please add your names here
If there is a clear time limit on this stage, as the feature has been requested and funded by a user/instance this will be made clear on the original post.
Stage Two: Confirming a Specification
Currently this stage is generally led by the team that is funding the majority of the development. This stage takes the broad set of ideas and goals and begins to develop a clear specification for the work. A clear specification should answer all of the developers questions, and thus cannot be created without developer input.
To develop and finalise the requirements spec one or more meetings will be required. Limiting to a smaller set of people at this stage, including ‘head developers’, developers that are likely to work on the issue and ‘product owners’. During this stage the team that will work on this project will also be decided.
A requirements specification will likely include things like:
- High level requirements
- Any assumptions that need to be made
- Use cases and user journeys
- DB Changes required
- Ideas for the UX
- Implementation steps. Include review, test and merge here.
Once developed the requirements specification should be made available for the whole community. If there is a deadline for comments/feedback, or if no further comments/feedback can be made by the community at this stage due to timescales, this will be noted in the document.
It seems sensible, at this stage, to also designate a project lead that will drive the project forward.
The requirements specification document should be linked from the original discourse post.
Stage Three: Estimation
After a specification is agreed the development, implementation and testing will need to be estimated.
Estimations will be made based on the estimated time required for each of the implementation steps in the spec, including review, test, merge and user guide updates.
These estimations can then be translated into project cost, which will in part be indicated by the people that are likely to work on the project and their day rates (which differ from country to country based on differences in living costs).
A breakdown of project costs can be linked to the discourse for transparency.
Stage Four: Funding
Once a budget for the project has been decided the project can be added to co-budget.
Find the description of how to do this here:
Stage Five: Development
Once a co-budget project has been fully funded development can begin. Firstly the implementation tasks are added as Github Issues. These issues should be added under a new Project so that the issues can be tracked.
More insights into creating Github issues can be found here:
While development is ongoing it is important for devs to track their time such that budgets can be monitored.
During this stage it is a good idea to merge code in smaller chunks as you go, to save big conflicts and merges as the project starts to wind up.
There will likely be a few iterations of development as features are tested, either internally or by the community, issues are found, fixed and retested.
Development phase is complete when developers, testers and product owners are happy that it meets the spec for this phase of the project. Note that this might not be the project in it’s entity… and might not satisfy all the needs of all the users. In that case it’s back to Stage One to work out what to include in the next round.
Stage Six: Merge and Release
Once the new feature has been signed off by developers, testers and product owners it is ready for release. At this stage descriptions of how to use the new feature should be added to the user guide.
- As yet there’s no guide as to how to fund the initial scoping and speccing work. Some of this work is done by the community and some needs high level technical skill that should be remunerated.
- How do dev track their time while working on project issues such that budgets can be monitored as we go?
Probably @ the whole community on this one… who else?