This is the second in a short series of articles exploring my current state of thinking around implementing learning technology solutions.
In the first post, I looked at the scoping & kick-off stages – the essential foundations for a successful project.
This time I’ll focus on the “Project setup” stage. This is a piece of housekeeping that is often forgotten in the rush to get started building something. It includes:
I’m using terms that come from Agile development practices, but don’t let that put you off… Even if you’re using other project management methodologies these ideas should still be applicable.
Whether you’re defining all the software requirements up front, as per the typical “waterfall” project, or defining them as you go in an agile project, you will still need to document how what needs to be done.
These are your user stories.
Ideally they would contain an overview of what should be created from the user’s perspective, and then some detail which provides enough information to be able to do acceptance tests.
For example, the overview statement might be:
As an administrator, I need to be able to allocate users into groups so that I can efficiently manage who is doing which course.
And the subsequent detail might then be:
GIVEN that I am logged in as an administrator
AND some users exist
AND a group exists
WHEN I add a user to a group
THEN the group records the new user without errors
This (highly stylised) example is an illustration of the Given-When-Then pattern, which is designed to help write requirements that can be easily tested against.
User stories like this often benefit from screen designs or mockups to help the developers.
The key thing at this point is to agree what quality will be expected for the user stories. What level of detail will be required?
In a similar way to defining how you know a user story is ready, you’ll need to agree how you know a task has been completed, the definition of done. It’s not just about saying something is finished, it’s about making a statement that the task has been finished to a certain standard.
The definition of done sets that quality standard and should be published and known by all team members.
Often this is called the definition of done done. It means that all the functionality is in place, the user interface has been fully built, it’s been through unit, integration, accessibility and systems testing, there are no blocking bugs, the documentation is complete etc.
Again, those quality standards should be published and accepted up front.
OK, not everyone will use visual management boards to run their projects. In traditional environments, you’ll most likely still find the project managers use Gantt charting software like MS Project or Merlin. These are incredibly powerful pieces of software, that do far more than just the basic visualisation of a project. They also help manage resourcing and budgets.
However, in a fast moving environment, you’ll often find that a visual approach to management works best:
- Save time by simplifying the complex – Visual management helps people understand complex information at a glance, like what work items should be prioritized and why.
- Reduce waste by communicating effectively – Take the guesswork out of teamwork by letting people see their work.
- Overcome impediments – See where work has slowed or stopped and take steps to fix it.
- Collaborate and improve – Visual management encourages collaboration among a team because everyone can see what everyone else is working on.
The best example I’ve seen of visual management in practice is when the Swedish Police needed to completely rebuild their case management software. The book Lean from the Trenches is an easy, but challenging read as may totally change your perceptions on how projects should be run.
For a flavour, take a look at the author’s presentation to a developer’s conference a few years ago:
If you’re going to have multiple people creating code for your project, then you’ll need them to have the identical environments in which to do their developing. Otherwise you run the risk of the code working for one developer, but not for another.
Vagrant is one of a number of tools that may help.
Vagrant provides easy to configure, reproducible, and portable work environments built on top of industry-standard technology and controlled by a single consistent workflow to help maximize the productivity and flexibility of you and your team.
Of course, if you’re just configuring SAAS software then you don’t need to worry about this!
Apart from the small, low budget projects, it’s very rare that you’ll find a software implementation project that just puts the software on a live server and does all the development, configuration and testing on there.
Normally you would want to have three server environments at a minimum. These are in addition to the developers’ local installations where they do the basic functional unit testing.
Again, if you’re not developing code, this may be irrelevant.
Developers often have strong preferences, so it’s good to air these at the beginning…
Even if you’re not developing code this is still important. In most implementations you’ll be wanting a number of software components to talk to each other. For example, you might have an HR system, a Learning Management System and a content repository.
Software architecture looks at:
It normally starts at a very high-level, focussing on the things that are going to be difficult or expensive to change later, and then moving into requirements analysis – the lower level of detail that developers and configurators will work with.
Your developers and configurators will need something to do when the project starts, so this is the point at which you define those first tasks – following the quality standards you’ve already set out.
Each user story should have a rough size attached to it. I use the Fibonacci method for sizing, as it helps to show the relative sizes very easily. Anything that is an 8 or above should really then be broken down into smaller user stories, to make it more manageable. This is especially true if you’re working in 2 week sprints; aiming to complete a number of user stories within each sprint.
Prioritization is a bit of an art form. You’ll be guided by:
The aim is to build something that works and is usable. It might not have all the bells and whistles, but it gives the customer enough to get going with.
Note that there are caveats to this “incremental development” approach. See: The myth of incremental development
It might be that you can build something suitable in a 2 week sprint, or the first iteration may take 6 months. However, the shorter you can make the iterations the more easy it is to respond to changes in the the requirements.
Posted: 17 April 2015