One question I am asked often is how I manage my SharePoint projects, what stages I go through and how I perform/manage each phase of a project. This is probably something you already do, but perhaps it’s good to see some examples of how other people manage projects, so feel free to read along.
This is a high level summary of what I do in a typical project and is not every individual item. SharePoint is also mentioned throughout this article because it is the technology I most often use when working on projects and organizing information.
Before the Project Starts
Before I start a project I create areas to capture knowledge (KB, and lessons learned), following that I begin the process of the project itself. This is important to do right at the start because even during the pre-project phases you can come up with some interesting notes, concepts, or lessons learned.
Right now I always do this knowledge capture using SharePoint with a mixture of wiki’s and related concepts. So this area is already built and all I need to do is create a ‘project’ and ensure the ‘customer’, ‘client’, and ‘area of business’ represented is also within the knowledge area to ensure anyone who comes up with something new can create articles, upload documents and basically create content that will be associated to that project, client, or business area.
I normally break a project down into the following phases. Every project, regardless of the size. The good thing is that I do NOT enforce specific templates for each phase. I love the idea of templates in that they can save you time and certainly have some that I can make use of, but it’s important to not force yourself to fill out a document and certain content placeholders just because ‘its part of the template’. This can often create confusing statements, is a waste of effort, and really can detract from the important parts of the document.
I always start off with some sort of domain analysis. That is analysis of the current environment, configuration, and system that is in place. How do things interact with one another? What applications already exist? What version are they? How are they used?
The results of this analysis will should contain an overview of the current servers, third party applications, shared service providers, configurations, and web applications, and existing site collections. I personally like to use excel documents for this (I know I could use SharePoint lists and may consider doing so in the future). Once these have been identified and cataloged the next phase of work can begin.
Based on the objectives and target audience a series of business requirements must be retrieved. These requirements can come from business stakeholders, potential administration, and end users. It may be necessary to hold requirement gathering workshops with various involved parties in order to better understand how people would like to use the eventual system and how the system can provide them the most benefit.
Important things to note from personal experience during the requirements gathering phase:
- Involve every stakeholder in this requirements gathering. Even if it’s just to briefly talk about the requirements you have gathered from a high level. This will allow them to feel more involved in providing any input and requirements they might have and ensures that later when the system is being developed or implemented there are no significant surprises or missed requirements.
- Ensure you document the motivational reasons for a requirement as well as the requirement itself. This can really help you or the individual drafting the technical specification determine the correct solution for that individual requirement. This sounds simple but you would be surprised at how many people just document Requirements 1A-200C and forget to explain why these requirements even exist. This also can help you if later down the road someone says why did we do this?
- Prioritize the Requirements. Its important to identify ‘must have’, ‘would like to have’, and ‘if there’s time’ categorizations for every requirement. Its also a good idea to have further priority information. This extra priority information combined with the motivational reasons should make it clear where you need to spend most of your time, or make sure that the solution absolutely covers these areas.
These requirements and the knowledge you have gained from the client now allows you to create what is often referred to as a functional specification. This outlines how the users expect to interact with the system, outlines their requirements and ensures that unanswered questions are resolved.
Some important points:
- Only one person should OWN (and write) the functional specification. This is very important. This ensures one person is responsible, one person can be referenced for information, and that the creative ideas and concepts represented (while based on many peoples input) is written and communicated by one individual. If the project is very large and this doesn’t seem feasible for one person break it into two smaller projects and have each person write their own specification for a part of it.
- Always have a developer or someone who will be writing the technical specification review your functional specification. This review should help point out gaps in the document, or knowledge so that you can interact with the client and retrieve answers without disrupting the technical specification process. (You don’t want the technical specification to start until the functional requirements have been hammered out if at all possible, that way you will not potentially need to redo some technical specification work if requirements change.)
- There should never be a question mark in the functional specification. Everything written in here will be signed off on and it should be complete. Ensure if you aren’t sure about something that it is classified as out of scope.
- The functional specification must not contain details on how it will be technically implemented. This is the kind of information that should be contained in the technical specification which is developed from the functional specification. The functional specification should contain a ‘from the user’ perspective.
- If possible provide scenarios. Scenarios are one of the easiest ways for any reader to understand something. It gives a real world example for how something works and can provide addition insight into why, and how it could be done.
- Make it READABLE. This one is very simple. If possible make it fun to read, or if that’s not possible ensure the language it is written in is to the point and easy to read. Never complicate it with business jargon or add extra adjectives to describe something just because you want to sound savvy or the document to seem ‘more professional’.
- Include a sort of ‘executive summary’ or overview that is short, to the point and describes high level what the functional specification outlines in more detail. This will allow those who don’t need to read the entire thing to still understand the information it contains.
- Include as much detail as possible. If you outline that there is a requirement for notification to be sent to a user make sure you write exactly what the notification will say, and identify any options or actions that can result from this notification.
Design and Architecture
Technical Specification and Architecture
Developer or Architect creates a technical specification or a ‘design doc’ as often I hear it being referred to as. Content contained in the technical specification can include how the solution will be built, what technologies will be used, what the server requirements and hardware requirements are, stuff like that.
Provide specific instructions for how things will work and if possible their dependencies. As an example if you know your end solution will most likely utilize a notification service that will require email provide this information in a clear manner so that upon sign off (or even before sign off) the analyst, consultant, or account manager assigned to interact with the client can begin getting you the things you eventually will need.
Graphic Specification, and Visual Design (or Screen Engineering)
With the technical specification complete we can now document how the screens, components, messages, and features will look to the end user. To be honest, I am not a graphic designer, or even really a designer. So my advice on this area is going to be limited in scope.
What I would recommend here are these few things:
- Make a specific note that these are recommended screen designs but that the end result may differ slightly. The initial screen designs rarely capture every single aspect of the solution and do not get modified at some point. They are the guideline and really help clients, developers, and anyone else involved understand what to expect. Since this is setting their expectations make certain they realize that minor adjustments may be necessary to make it more functional or user friendly down the road.
- Notify the client of any graphical changes. If you do make a graphical change or desire to make one after the client has signed off and the project has started in earnest, make certain you notify them. Get them involved even if it’s not an active role to make sure that it reduces potential trouble down the road.
- Do not add extra functionality to make things look nicer. Keep in mind you have a limited amount of time for this project. The designs should mirror what is outlined in the functional and technical specifications. Often (by accident) a graphic designer may adjust something to make it look nicer but not realize the implications that adjustment can have. It’s important to think about everything that might be effected by visual adjustments.
- Have technical staff review the design. Don’t just have the analyst, or consultant review the design make sure the developers also review it. They may point out inconsistencies or potentially better ways of presenting information or taking user input. They know the tools available to them, and in SharePoint as an example will know the effort required to style and adjust certain items, over others. (Example changing the way a list presents information as opposed to adjusting a master page.)
Development Plan, Communications Plan, Training Plan, Support Plan, Governance Plan, and Project Plan
Based on estimates for how long tasks should take and a logical rational breakdown of responsibilities create a project plan. I normally use Microsoft Project because it makes it easier to modify later, tell what’s on the critical path, manage resources across projects, and so on and so forth.
Important Note:Don’t forget your communication, training and support plans! These should be all elaborated on and clearly identified at this stage along with their time and associated cost. SLA agreements might be created here, or communication plans. So keep in mind that while I am only describing briefly the project plan and development plan that there are a great many other potentially required plans and agreements necessary before you should move beyond the planning stage.
Include clear identification of how the system will be governed in a governance plan. This is especially important for SharePoint deployments and is probably the single biggest thing I often see missed. Here is a TERRIFIC sample of a governance plan created by Joel Oleson and Mark Wagner: http://go.microsoft.com/fwlink/?linkid=92333&clcid=0x409
Create a development plan based off of the technical specification and the design specification. Ensure all estimates, times and tasks have been delegated under this plan.
Depending on the environment I like to use a RACI model for both plans.
RACI in this case stands for Responsible, Accountable, Consulted, and Informed. Basically for each developer/team member I make sure that it is clear whether they are responsible, accountable, need to be consulted, or need to be informed of each and every task. This is normally pretty easy to do, but it makes sure that everyone always knows who needs to be consulted with, informed of changes, or who is accountable for a task being complete etc.
This doesn’t always make sense. There are some teams that may take offense to the concept, and it isn’t always the easiest thing to keep track of. However in important projects I believe this is an integral piece because without a RACI model implemented you cannot always determine what might have gone wrong, or how it can be resolved in the future. Personally I always use one and fill it out regardless, but it is best if each member has input and agrees to the RACI for each task.
One thing I also do is often use Project Server to really expand my capabilities in regards to being able to show the project plan, baselines, etc without actually requiring a user to download project. This is especially important because project can really be a scary big thing for most users upon first beginning to use it. It also saves lots of cost and some space on all the developer and related project personnel.
Specification and Project Plan Sign Offs
All stakeholders sign off on the functional, technical, and design specifications as well as the project plans. Everyone must be in agreement from the customers to the teams that will be implementing it. This saves time down the road, as it’s more costly to make changes to projects further into the project and ensures that all involved parties have been included and have taken responsibility for the solution.
If there is trouble making the technical specification most of the time it is because the functional specification and requirements have not been fully identified. If the design specification has lots of trouble then it’s probably the functional or technical specification that might be at the root of these issues.
The development phase is fairly straight forward. The technical specification has broken down the technical details. The design specification has broken down the look and feel. The development plan has broken down the tasks and responsibilities.
With all of those in place this is a smooth and easily managed phase of the project. It also has HIGH visibility of where things stand because you can always compare against the development plan, technical spec and visual designs.
Standards are a wonderful thing but continue to evaluate them to ensure that they remain current, relevant, and useful. Keep things structured if possible as this helps you keep estimates more accurate. However do not crush your teams with impossible to meet standards. These provide no benefit and detract from the important of standards. Make sure all goals and standards are attainable and have clear indication of why they assist developers and team members.
One thing that I have seen over the past few years is a new more specific form of testing for security. In today’s world security is becoming more and more specialized and more and more important. To this end it might make sense to have a security team perform security tests, provide input on potential vulnerabilities, and often elaborate on ways to improve security for the code, application or system.
Unit Testing and QA Testing
There is unit testing and there is Quality Assurance testing. These are totally different things. In unit testing you will test individual components, and then STILL in unit testing you will test things integrated with one another often in a SIT environment. When all of this testing is completed and everything looks perfectly solid you move it to QA for testing. But only once you have fully tested the components.
QA will evaluate whether it matches the visual designs, and the functional specification. In some cases also the technical specification. Their job is more to just assure that the quality is there and come up with tests that the development team would not have thought of. Unexpected user inputs, or ways in which the user can use the system (still using the functional specification as a guideline) that maybe the development team missed.
It is important to have a SIT (integrated testing area for all the individual modules and components) environment for development as well as a seperate QA environment. Keep in mind that all these environments should match as best as possible the client’s environment to avoid environmental issues and troubleshooting that might be needed down the road.
Before you deploy anything anywhere it should be clearly documented what you will do, what performance and outage’s it could result in, and how the changes you make can be undone.
Along with all of this you should also have any help documentation, user manuals, administrator manuals, and other documentation that is produced in your project complete or very clearly defined before implementing any solution on a client’s environment.
Lastly, document exactly what you do in that environment so that you can diagnose issues, or protect yourself from being blamed for unrelated issues.
User Acceptance Testing is very important. This is where users review the solution in their own environment and ensure that their expectations have been met and that it is a usable beneficial system. Earlier in the plan it was important to note that any communication and training should be clearly identified. It is also important to note that if at all possible preliminary training at least should be done before UAT. This will ensure that your resources at UAT are not teaching people how to use the system as much as ensuring it meets or exceeds all of their expectations.
For projects where the client doesn’t have the money or interest in training I normally expand the UAT cycle to account for the fact I (or my team) will also be training while performing the user testing.
UAT Fix and Testing Cycles
Taking any exceptions from UAT and ensuring that they are fixed and fully tested and then if needed ensure that the user has accepted the changes as well before moving on to the final deployment.
These cycles can often go back and forth more than once depending on how good communication with the client has been, how well client expectations have been managed, and how accurate the initial specifications and plans were.
Your last deployment (aside from updates and new releases). This follows the same documentation rules as before.
Communication and Training
This is the full training, and communication phase. Often this could be workshops, webcasts, training sessions, assisting the organization with posters and improving internal user acceptance or user adoption etc etc.
Support and Feedback
SLA’s might contain what your support details are. Often this could be fixes, warrantees, upgrades, or even live support. It really depends on what you identified with the client. I also like to ensure that feedback is gained from the client. This provides a wonderful opportunity to create business references, case studies or other great marketing tools because the solution is new, exciting, and in (hopefully) most cases the client is very happy and satisfied.
Hope this helps someone or stirs some ideas for how to better manage your project through it’s phases,