Thursday, 25 September 2014

4 simple hacks to boost your sales and marketing efficiency

MarketingToolsForEntrepreneurs

I know his name … How do I get his email address?
How do I get to know more about this guy?
Did he open my email? Did he read it? Should I write again?
Eureka, Will send a mail in the evening.
(next day)
Oh God, totally forgot to send!
Oh God, I had to follow up with him last week …. Totally forgot …
He is not in my network, how do I get in touch with him?
Does this sound familiar? These are common day to day obstacles holding us back everyday in our path to glory. This not only leads to productivity loss, unnecessary delays but a lot of frustration as well.
I have myself suffered for a long time because of this and decided to take matters in my own hand. After a lot of research and experiments with various tools for over more than 12 months, I found answer to most of these problems. I was mighty surprised by the simplicity of these solutions and thought of sharing them.
In this post, I am not going to give the traditional route of various standard complex tools available but rather show you a few simple yet powerful tricks that work to improve your efficiency:
Yesware: Next time you want to know who opened your email, when was it opened, where was it opened? Look no more. This powerful tool will take care of all of this and give your powerful analytics to measure as well. I use this very effectively to know when to follow up and to whom. To top it up, you can even set up reminders to follow up if you have not heard up from your prospective customer/anyone. You all know, reaching out to your prospect at the right time is heck important to close a sale. A must have if you are targeting a lot of people and want to make the impact you looking for.
Note: The paid version has a whole bunch of powerful features to make you look really sexy.
Rapportive: Next time you need to find out an email address and want to know a little more about the prospect to send a personalized email and not sound cold, be sure to check out the Rapportive extension and this excel file to find anyone’s email address.
Rapportive extension gives you a brief about the person available from his social profiles including LinkedIn by just having their email address (even if you aren’t connected to the person). The excel file will allow you to have a number of possible email address by just knowing someone’s first and last name. Then, you put those email addresses one by one in your compose window and if the email address is valid, the rapportive extension will show you their social profiles. It’s just a brilliant way to find out anyone’s email address in a whiff. So, now crib no more about not having anyone’s email id to reach out to and just shoot your way into your prospects inbox. Happy mailing.
Boomerang: Another brilliant tool that I love. Are you the kind of person who has a thousand eureka moments a day and want to shoot out an email immediately (even if it may not be the correct time to send the mail, given that the chances of the other person opening the mail is low)? Well, then you are no different, there are millions of them with the same problem. Now, this is where Boomerang comes in, use this tool to create the message with the eureka idea that just popped and schedule the mail for a date and time you deem will make the most impact. The icing on cake is “Remind me” feature, if you want to follow up with the person after sometime in case you do not hear from him then use this feature to get a reminder to follow up. That’s it. No more getting lost in the maze of emails.
LinkedIn Groups: A kickass method to message a Linkedin user if you are not connected to him. This is one of the lesser known yet powerful tricks to get in touch with someone. Let me tell you now on how to do it: A) Assumption, you are not able to connect with the prospect B) Do not have any common connects to ask for reference. To connect with your prospect, the first thing you need to check is the groups you are associated with. Join the groups he is in blindly. Go to the group and then click on members tab. You will be surprised to see that you are allowed to message the member even if you are not connected to them. Cool, right? Happy sane spamming.
These are small yet extremely powerful tools to take your sales and marketing process to the next notch and make you fall in love all over again. There are few more powerful tools for growth hacking but these are a good starting point. These have personally done wonders for me and I would recommend all to use it and more.

Wednesday, 10 September 2014

7 Programmer Recruiting Mistakes

We’ve all met them. The programmers that can’t program. They can hardly write anything that compiles on their own. Producing quality quality code is way above their skills. Somehow they still get hired. Trying to find out why, I’ve listed 7 common mistakes made during recruiting.

The Seven Mistakes

  1. Focusing on years of experience.
  2. Trust peoples own assessment of their skill.
  3. Don’t ask the candidate to write code.
  4. Recruiting for “the other team”.
  5. Be forgiving to spelling mistakes in the CV.
  6. Focus on technical skills and not communication skills.
  7. Fear of hiring someone better.

Focus on Years of Experience

Years of experience is simple and objective to measure. For any single individual any added experience adds to the skills, so it’s natural to make the conclusion that the number of years of experience is the most important measure for skill.
Unfortunately that conclusion is totally flawed, especially for programming. The single most important skill to become a great programmer is talent. Some people have the aptitude to become a programmer; some doesn’t. The number one priority when recruiting programmers is to find out if the candidate has the aptitude. If the candidate hasn’t, several years of experience won’t help. The candidate isn’t and will never be a great programmer.

Trust Peoples Own Assessment of Their Skill

When interviewing I always ask the candidate of their own assessment of their skill in different areas. Knowing their own view of their skills is critical, but I would never trust them. The problem is that those with the highest competence will usually be very humble. On the other hand there will be candidates that has some basic skills and will boast about it.
Instead of trusting the candidates’ own skill assessment I’m looking for candidates with a realistic view on their skills.
I also use the question to find out the areas where the candidate claims the highest competence. Then I pick one of those areas for the code test. I’m trying to be nice, letting the candidates show their code skills in their strongest area.

Don’t Ask the Canditate to Write Code

I think that a code test is a critical part of a programmer’s interview, yet many people obviously ignore it. I’m astonished by that, because there are people that can talk, but get completely stuck when asked to write code.
The code test doesn’t have to be very hard. Those who can’t program at all will show that even on a simple test. In my recent interviews I’ve used two tasks.
The first is about data access. I present a small database with the tables Persons and Cars. There is also a foreign key from the cars table to the person table pointing out the owner of each car. I let the candidate explain how the relationship is to be implemented through a foreign key, which also requires establishing a primary key on the person table. Then I ask them to produce a simple result set.
Car Reg NoOwner Name
ABC123Anders Abel
LDB109Anders Abel
CED456Albin Sunnanbo
I let the candidate choose between LINQ and SQL for implementing the query. Either way, for an experienced developer that is used to writing data access code the query should be really simple to write down.
The other I’ve been using is to write a subclass Square to a Shape base class that I provide.
public abstract class Shape
{
  public abstract float GetArea();
}
I’ve also thought about asking people to solve the fizz buzz problem but haven’t yet taken that step. What do you think, should I give it a try?

Recruiting for “the other team”

At the end of the interview I always ask myself the critical question.
Would I like to have this person in one of my projects, sitting at the desk next to mine for several months?

If not, it’s a no hire. As Joel Spolsky writes in his Guerrilla Guide to Interviewing it’s a bad idea to recruit for the other team:
Never say, “Hire, but not for my team.” This is rude and implies that the candidate is not smart enough to work with you, but maybe he’s smart enough for those losers over in that other team.

Be forgiving to spelling mistakes in the CV

Before doing an interview I always read through the CV of the candidate. Of course I look at the information provided, but I also look closely at how it is provided. Does it have a good structure? Is it spelled correctly?
Written communication skills are always important in any programmer job. Even though the programmer will mostly be writing code they should also be able to write documentation and occasionally write emails to the customer. If they can’t express their CV clearly they will probably not be able to express anything else clearly either.
If there are a lot of spelling mistakes that any word processing would mark as incorrect it is a sign of pure laziness to leave them without fixing. If the candidate is lazy about the job application, there’s a huge risk for laziness in the job too.

Focus on technical skills and not communication skills

People sometimes claim that spoken communcation skills are not important for programmers. As long as they write great code that’s all that’s relevant.
In a team environment nothing can be more wrong. It doesn’t matter if everyone in the team writes great code if they can’t communicate their intentions. To produce a great result the team has to work together on a collective idea.
I usually ask the candidate to outline the architecture of a previous system worked on. It doesn’t really matter what system it is. What I look for is if the candidate has understood the basics of the architecture and can communicate it.

Fear of Hiring Someone Better

The technical interview (if there is one at all) is usually performed by a senior developer or architect. That developer probably has a certain position in the company, being the only one knowing how to solve the really hard problems.
What happens if an equally good, or maybe even better, programmer is interviewed? There are two possible reactions from the interviewer.
  • This person is really good, I won’t be the best at the company any more. This will threaten my entire position.
  • This person is really good, finally I’ll have someone that challenges me. Together we can form a really strong team and become even better.
The threat thought is very common (not only among programmers). Unfortunately it leads down the road of ever falling competence, if everyone always recruits someone that is less competent than themselves.
Would you dare to hire someone that might be better than yourself?

Hiring is Hard

Hiring is hard and requires hard work. It requires self confidence to dare to hire someone that can challenge yourself (in a positive way). It requires some very tough decisions in the end, taking the “no hire” option even if their is a huge pressure from management to grow the company.
I sometimes think of recruiting as having a single date and then having to decide whether to break up or propose. It’s a decisions about what people you will spend 40 hours a week with for the next few years.

Thursday, 28 August 2014

Agile Software Development Methodologies Overview

Agile Software Development Methodologies Overview

Agile software development is a group of software development methodologies based on iterative and incremental development, where requirements and solutions evolve through collaboration between self-organizing, cross-functional teams.

Agility is dynamic, context-specific, aggressively change-embracing, and growth-oriented. It is not about improving efficiency, cutting costs, or battening down the business hatches to ride out fearsome competitive ‘storms.’ It is about succeeding and about winning: about succeeding in emerging competitive arenas, and about winning profits, market share, and customers in the very center of the competitive storms many companies now fear.

Agile methods emphasize face-to-face communication over written documents when the team is all in the same location. Most agile teams work in a single open office (called a bullpen), which facilitates such communication. Team size is typically small (5-9 people) to simplify team communication and team collaboration. Larger development efforts may be delivered by multiple teams working toward a common goal or on different parts of an effort. This may require a co-ordination of priorities across teams. When a team works in different locations, they maintain daily contact through videoconferencing, voice, e-mail, etc.

No matter what development disciplines are required, each agile team will contain a customer representative. This person is appointed by stakeholders to act on their behalf and makes a personal commitment to being available for developers to answer mid-iteration problem-domain questions. 
At the end of each iteration, stakeholders and the customer representative review progress and re-evaluate priorities with a view to optimizing the return on investment (ROI) and ensuring alignment with customer needs and company goals.
Most agile implementations use a routine and formal daily face-to-face communication among team members. This specifically includes the customer representative and any interested stakeholders as observers. 
In a brief session, team members report to each other what they did the previous day, what they intend to do today, and what their roadblocks are. This face-to-face communication exposes problems as they arise.

Agile Software development life cycle support
The Agile methods are focused on different aspects of the software development life-cycle. Some focus on the practices (extreme programming, pragmatic programming, agile modeling), while others focus on managing the software projects (Scrum). Yet, there are approaches providing full coverage over the development life cycle (DSDM, RUP), while most of them are suitable from the requirements specification phase on (e.g. FDD). Thus, there is a clear difference between the various agile software development methods in this regard. Whereas DSDM and RUP do not need complementing approaches to support software development, the others do to a varying degree. However, DSDM is available only for the members of the DSDM consortium, and RUP, then, are a commercially sold development.

Agile Modeling is a practice-based methodology for Modeling and documentation of software-based systems. It is intended to be a collection of values, principles, and practices for modeling software that can be applied on a software development project in a more flexible manner than traditional Modeling methods.
Agile Modeling is a supplement to other agile methodologies such as:
·         Extreme Programming.
·         Agile Unified Process.
·         Scrum.
Agile Methodologies

·      Extreme Programming (XP) : 

It advocates frequent "releases" in short development cycles (Timeboxing), which is intended to improve productivity and introduce checkpoints where new customer requirements can be adopted.
Other elements of extreme programming include: programming in pairs or doing extensive code review, unit testing of all code, avoiding programming of features until they are actually needed, a flat management structure, simplicity and clarity in code, expecting changes in the customer's requirements as time passes and the problem is better understood, and frequent communication with the customer and among programmers. The methodology takes its name from the idea that the beneficial elements of traditional software engineering practices are taken to "extreme" levels, on the theory that if some is good, more is better.

·         Agile Unified Process(AUP):

It is a simplified version of the IBM Rational Unified Process (RUP) developed by Scott Ambler.
 It describes a simple, easy to understand approach to developing business application software using agile techniques and concepts yet still remaining true to the RUP. The AUP applies agile techniques including test driven development (TDD), Agile Modeling, agile change management, and database refactoring to improve productivity.

The AUP has only seven disciplines:
  1. Model: Understand the business of the organization, the problem domain being addressed by the project, and identify a viable solution to address the problem domain.
  2. Implementation: Transform model(s) into executable code and perform a basic level of testing, in particular unit testing.
  3. Test: Perform an objective evaluation to ensure quality. This includes finding defects, validating that the system works as designed, and verifying that the requirements are met.
  4. Deployment: Plan for the delivery of the system and to execute the plan to make the system available to end users.
  5. Configuration Management: Manage access to project artifacts. This includes not only tracking artifact versions over time but also controlling and managing changes to them.
  6. Project Management: Direct the activities that take place within the project. This includes managing risks, directing people (assigning tasks, tracking progress, etc.), and coordinating with people and systems outside the scope of the project to be sure that it is delivered on time and within budget.
  7. Environment: Support the rest of the effort by ensuring that the proper process, guidance (standards and guidelines), and tools (hardware, software, etc.) are available for the team as needed.

·         Scrum (development):
It is - a type of software engineering - an iterative, incremental framework for project management often seen in agile software development.

Although the Scrum approach was originally suggested for managing product development projects, its use has focused on the management of software development projects, and it can be used to run software maintenance teams or as a general project/program management approach.

Scrum is a process skeleton that contains sets of practices and predefined roles. The main roles in Scrum are:
1-      The “Scrum Master”, who maintains the processes (typically in lieu of a project manager)
2-      The “Product Owner”, who represents the stakeholders and the business
3-      The “Team”, a cross-functional group of about 7 people who do the actual analysis, design, implementation, testing, etc.

Finally, I wish you find this article helpful; but you have to know that there are too many other agile methodologies that I did not mention here.

Agile Project Management - Complete Refrence

Agile Lifecycle

All software development methods, including the Agile ones, have some sort of underlying project lifecycle. System Development Lifecycle (SDLC) is the common name for a software development process, but in the Agile world I prefer calling it a “heartbeat” reflecting the organic nature of an Agile project. Some of the big Agile methods don’t make a big deal of the heartbeat and others do. Some have such abstract lifecycles that it is actually hard to know what activities to schedule. And they all use different terms for the same thing. I have pulled out the common activities to create a generic agile lifecycle.

The key elements are a Project Initiation followed by one or more Releases made up on one or more Time-boxes (although usually 3), and ending with a Project Closure.


Agile Pre-project

There are some important questions to be addressed before the start of any project like “Why are we doing this project?” and “Should we do this project?” Project Initiation is the phase where these questions are answered but some work has usually been done before.

Find/Write Project Brief

Projects don’t happen in isolation. The key question during project initiation is “Should we invest more?”, i.e. is the project worth going ahead with?  There must be a reason for the project. The first step during Agile Project Initiation is to find this reason. Often with software development there are just too many choices for what the team could do. A Project Brief can help remove this confusion by pointing the general direction in which the team is meant to head.
The format of a Project Brief document might be a Project Vision, in part of a Product Road Map or a Project Mission Statement but the key thing is knowing why we’re spending this money on this activity.
Marty Cagan of the Silicon Valley Product Group suggests we provide good answers to nine questions to know if we are pursing a good opportunity. The nine questions of the Opportunity Assessment are:
  1. Exactly what problem will this solve? (value proposition)
  2. For whom do we solve that problem? (target market)
  3. How will we measure success? (business metrics)
  4. What alternatives are out there? (competitive landscape)
  5. Why we are best suited to pursue this? (our differentiator)
  6. Why now? (market window)
  7. How will we deploy this? (gentle deployment strategy)
  8. What is the preliminary estimated cost? (small/medium/large)
  9. What factors are critical to success? (solution requirements)
I encourage Product Owners to answer these questions before launching the project proper.

High Fidelity Prototype

The Silicon Valley Product Group recommend a a High Fidelity Prototype rather than using documents to describe the target system.  If the Project Brief gets the go ahead then invest some time in putting together a click through prototype of the system.

Agile Project Initiation

Traditional Project Initiation

Initiating is one of the five project management process groups in the Project Management Body of Knowledge (PMBOK) from the Project Management Institute (2004).
In the UK project initiation usually means writing a Prince2 style Project Initiation Document (PID) or the equivalent.  Once you have the PID the Requirements Capture, Analysis and Design activity can begin.  All of which is rather time consuming.

The Project Initiation Document (PID)

The defining feature of the Prince2 Project Management method is the PID. It can take a considerable amount of effort to write this document. OGC: Project Initiation Document (PID) gives the suggested content:
  • As a minimum the document should answer the following fundamental questions about the project:
  • What the project is aiming to achieve
  • Why it is important to achieve it
  • Who will be involved in managing the process and what are their responsibilities
  • How and when the project will be undertaken
  • The PID has to answer the above questions to a sufficient level of detail to maintain control of the project. The document should cover the following areas:
  • Background, explaining the context of the project, and how we have arrived at the current position of requiring a project.
  • Project Definition, explaining what the project needs to achieve. Under this heading will be:
    • project objectives
    • defined method of approach
    • project scope what is included and what not
    • project deliverables and/or desired outcomes
    • exclusions
    • constraints
    • interfaces
    • assumptions
  • Project organisation structure, detailing who is going to be involved and what their responsibilities are (team management structure and job descriptions)
  • Communication plan, describes how the project stakeholders will be kept informed during the project
  • Project quality plan
  • Project controls, laying down how control is to be exercised within the project, and the reporting and monitoring mechanisms that will support this
  • Business case, covering the estimated costs, risks and benefits. The Business Case will require regular review throughout the project and may require updating
  • Initial project plan. The plan will be reviewed and further developed at regular intervals during the project
  • Risk register containing details of the identified risks so far. The Risk Register will be reviewed at regular points during the project to assess progress on managing risks and to identify new risks that may have appeared

Requirements Capture, Analysis and Design

These phases are all about identifying the requirements and then transforming them into a format suitable to hand to developers.  The Requirements are usually in business language.  Analysis, usually done by a systems or business analyst, extracts the logical requirements.  Design attempts to show how the logical requirements which be met technically.  These phases are all time consuming, happen in sequence, and involve different people at each stage.

Agile Project Initiation

The Agile methods are beginning to acknowledge that some upfront work is required to ensure project success. Project Initiation includes all the work necessary before full scale coding begins.
Agile Project Initiation includes these steps:
  1. Find/Write Project Brief
  2. Form the team
  3. Initial Plan
  4. Initial Requirements
  5. Initial Infrastructure
The difference between Project Initiation and the equivalent in a traditional waterfall process is that Project Initiation is time boxed and the Agile Team do the work.  a couple of days is all you need for a small project and a month is fine for a large project. Given the short time period the initial deliverables will not be perfect but perfection is not the aim. The idea is to do barely sufficient work to begin developing a solution. For some deliverables, e.g. Release Plan and Risks and Issues Log, these will be only the first version of many created during the project.
For further information on activities to include in Project Initiation, check out the Business Study in DSDM (2002) and Iteration Zero in XP (Beck 2000).

Find/Write Project Brief

Strictly speaking the Project Brief should exist before the project but in reality this often hasn’t been done and the Agile Project Manager should to write/find it.

Form the Team

The Agile Project Manager mobilises the Agile Team and ensures the Agile Team has an appropriate work space and support.
An Agile Team should contain the mix of skills required to deliver the product. Common skills are Project Managers, Product Owner, Designers, Developers and Testers.
Agile promotes close collaboration between team members so advocates co-location of the team members. Co-location makes for better channels of communication and counters Conways Law which suggests poor channels of communication may be reflected in the structure of the end product (Wikipedia: Conway’s Law). If the team have a dedicated work area then they can use their workspace to display visible progress towards their Timebox Goal.
This is a good opportunity to do the following.
  • Identify and arrange any necessary training
  • Set up recurring meetings and book rooms for Timebox Planning, Demos (also book a projector) and Retrospectives
  • Arrange for the team to sit together
  • Order a board if you need one
  • Prepare for the first Timebox planning ( See: Timebox Pre-Planning)
  • Create a project space and decorating it with material, staking it as the informative workspace as defined in the Agile glossary.

Initial Plan

The Release Plan is a reflection of features to be developed over time. The desirable features of a product are prioritised and then divided by Timebox with the most important features developed first. See the section Release Plan for more details. The division by Timebox is a result of the current velocity of the team being mapped against the current story point backlog for the project.
This is a good time to start the Risks and Issues Log.

Initial Requirements

The Product Owner is responsible for delivering the initial requirements during Timebox Zero.
There is no need to provide detailed requirements for subsequent Timeboxes at the start of the project. This will allow requirements to develop during the project with minimum overhead.
In terms of requirements that means doing:
  • High level requirements for the entire project
  • Detailed Requirements for Timebox One
The high level requirements are for the entire project.  Facilitated workshops are an effective mechanism for eliciting the requirements from the stakeholder group fast. The high level requirements drive the the Release Plan.
Agile is about doing the barely sufficient documentation to facilitate the next step in the process.  That means only enough detailed requirements are specified, agreed and understood to keep the team busy for the first one or two Timeboxes. Ideally the detailed requirements include Visual and User Experience Designs.
Silicon Valley Product Group recommend a a High Fidelity Prototype rather than using documents to describe the target system.

Initial Infrastructure

the technical staff set up the infrastructure for the project during Timebox Zero. This includes:
  • Environments
    • Developer and tester machines
    • Servers (development, continuous integration, test, UAT) including hardware and operating system, web servers, application servers, databases and permissions
    • Team Wiki
    • Set up and configure a bug tracker, agree bug process
  • • Version control and builds
    • Source Code Control repository (e.g. SVN) with access for developers and tester(s)
    • Tools for Continuous Integration (e.g. Cruise Control, Nemesis)
    • Continuous Integration up and running on your project in your source code repository
  • • Test Driven Development frameworks
    • Tools for automated testing (e.g. JUnit, JMock, JSUnit, Selenium, FIT, Fitnesse, DBUnit, XMLUnit)
    • Agree method(s) and depth of unit testing
    • Agree methog(s) and depth of acceptance testing
    • Agree the high level scope and approximate timing or frequency of other tests, for example accessibility, performance, security
    • Decide, set up and configure a framework for acceptance test automation
    • Write just enough code to support the automated build, continuous integration system, and automated test framework in use.
The technical staff, led by the Technical Lead, also do the first high level version of system architecture.  The systems architecture document outlines both the hardware and software of the intended solution. It describes the target platform and (if different) the development platform. It also explains the software structure including major components and their interactions. [Some Agile methods are very keen on emergent design, but you have to start somewhere.]

Environments

Not really Agile per se but I thought it worth having a mention of the environments a development team will need. There are quite a few.
 
Promotion Path to Live
EnvironmentPurposeWhen to useRelease ControlWho Controls
DevelopmentWhere the developer does their thing.AlwaysControlledDeveloper
Continuous IntegrationWhere the continuous integration build appearsAlwaysUncontrolled
Automatic System TestWhere the automatic tests run if the Continuous Integration box can’t handle the load.If have to split test because they run too slowUncontrolled
Manual System TestWhere the Testers check out stable releases.AlwaysControlledTester
Automatic Integration TestTo integrate all of the components when there are multiple development teams working on a shared product.  Kicked off by an automatic process.Multiple teams integratingUncontrolled
Manual Integration TestDitto but for the integration testers to use.Multiple teams integratingControlledIntegration Tester
Hot Fix DevelopmentTo maintain a live copy of the software using Hot Fixes, whilst developing new functionality in parallelWhen system is liveControlledDeveloper
Hot Fix Continuous IntegrationDitto; this is were the continuous integration build goesWhen system is liveUncontrolled
Hot Fix Pre-productionDitto; this is were the Hot Fixes are tested before going live.When system is liveControlledProduct Owner
Pre-productionThis is where manual user acceptance testing usually takes placeAlwaysControlledProduct Owner
ProductionLive.AlwaysControlledProduct Owner or Operations
  

Agile Project Scope

According to Wikipedia: Project Management project scope is:
The overall definition of what the project is supposed to accomplish, and a specific description of what the end result should be or accomplish.
We can talk about what is “in-scope”, i.e. what the project is meant to delivery, and what is “out-of-scope”, i.e. what won’t be delivered.
Typically the project scope is a subset of the scope of the product under development.

Traditional Project Scope

Project Scope Management is one of the nine project management knowledge areas in the Project Management Body of Knowledge (PMBOK) from the Project Management Institute (2004).
Traditionally the scope of a software project has been defined in a specification document of some kind. Terminology varies considerably and the document might be called a requirements specification, functional specification, or program specification. Regardless of the name the document describes the function requirements, i.e. the intended behaviour of the system being developed, and the non-functional requirements that constrain the design or implementation (e.g. performance requirements, quality standards, etc). (See  Wikipedia: Software Requirements Specification (SRS) orWikipedia: Functional Specification). These documents tend to be quite large.
Traditional requirements documentation can be characterised as both wide and deep, i.e. it covers the entire breath of requirements in considerable detail. The trouble with this approach is that generating such comprehensive documentation takes a lot of effort, and by the time the specification document is complete, it is also out of date.
And ironically in traditional project management any changes to the scope are seen as a threat to the project. Change Management is used to combat changes to scope.

Agile versus Traditional Project Scope

In an Agile project, as with traditional approaches, the scope defines what software to build and deliver. There are, however, several differences between the two approaches including the:
  • Attitude towards change in Agile
  • Documents defining the Agile project scope
  • Timing of producing the Agile requirements
  • Emphasis on high level requirements in Agile
Unlike the wide and deep requirements of the traditional approach, I characterise Agile requirements as high level and focussed. The scope of an Agile project is defined by high level requirements, in the form of User Stories, scheduled in the Release Plan. Detailed (or deep) requirements are still necessary but they are only created when they are needed – this is the focussed bit. That means that in Agile Project Initiation, the Product Owner produces User Stories for the entire project, but only produces supporting documentation for those User Stories scheduled into the first Timebox. During the first Timebox detailed supporting documentation is produced for the User Stories in the second Timebox, etc. This means that if/when the scope changes we have invested a minimal amount of energy in specifying out the bit that is no longer needed.
Whereas change is seen as the enemy of a traditional project and traditional Change Management is used to combat changes to scope, in the Agile world change is expected and Agile Change Management facilitates change. Seeing change as likely has an impact on the nature of the documents that define Agile project scope. Basically the documents have to be easy to change. In addition detail is left as late as possible to facilitate change. In the absence of detail the Agile Project Manager must use high level requirements, i.e. User Stories, as the basis of their Agile Project Planning.

Role of the Project Brief in Defining Scope

The Project Brief is a prerequisite for Agile Project Initiation. The Project Brief provides the context in which the User Stories are written.

Role of the Release Plan in Defining Scope

The Release Plan is the main deliverable from Agile Project Planning. It lists the User Stories that are in-scope and when they are scheduled for development. By implication it also indicates what is out-of-scope.
I find it very useful to have all User Stories, whether in-scope or out-of-scope, listed on the Release Plan. I flag the out-of-scope items as such as it is clear that they will not be built. This is mainly to avoid the inevitable discussion along the lines of
Product Owner: “But I asked for X”
Project Manager: “Yes you did, but you then deprioritised it to make room for story Y. We developed Story Y. Story X is out-of-scope”
This is an example of why Agile Change Management is important.

User Stories = High Level Requirements

User Stories seem to have become the defacto method for expressing high level user requirements in the Agile world. They originate in the XP world (Beck, 2000; Beck & Fowler, 2001), but the definitive work on writing user stories is “User Stories Applied” by Mike Cohn (2004).
User Stories are usually brief descriptions of the intended software behaviour from the user’s perspective. They can be brief because they are a place holder to a conversation between the Product Owner and the Agile Team and/or to supporting documentation.
User Stories are the base planning units used in Agile Project Planning.

Guidelines for Good Stories

Rachel Davies of Agile Experience advocates a user story format which is gaining increasing acceptance:
Story Title
As <role> I want <feature> so that <benefit>
This format not only tells the Agile Team what the feature is but which user needs it, and most importantly, why they need it.  The title is useful as a short hand for the rest of the story. I give each User Story a unique numeric ID as another form of short hand.
User Stories should avoid unnecessary detail, for example, they shouldn’t have details of the specific user interface. On the other hand it is essential that each story has at least one acceptance test associated with it before it reaches a Timebox to be developed.

Vertical versus Horizontal Slicing

Traditionally systems are planned and built by slicing up the work horizontally, component by component. As the work progresses the team adds extra building blocks to the product be they modules or classes.  This behaviour means that usable product features must wait until all the building blocks are in place before being ready, which might take several increments of the product.  This is problematic because the Product Owner cannot provide immediate feedback about the software until the full feature is delivered, long after the work started on it.
Agile uses vertical slicing. The software is built feature by feature, i.e. User Story by User Story. The Agile Team builds enough of each component (module or class) to meet the needs the User Story currently being worked on. That means the end of the Timebox, in the Timebox Review Meeting, there are more working features to be reviewed.  Instead of incrementally adding components the team is incrementally adding value. In this approach result, frequent feedback is possible to ensure that the software can evolve almost as quickly as the customer’s vision, maximising the chances that the customer actually gets the product they want.

Technical and Non-functional Requirements

This User Story format is useful for user oriented requirements but not for technical or non-functional requirements (performance, accuracy, portability, reusability, maintainability, interoperability, availability, usability, security, capacity). In these circumstances use whatever format is appropriate. For example, “The system must support peak usage of up to 50 concurrent users” or “Every page should load in less than 3 seconds”.

Splitting a User Story

There are at least three reasons to split a User Story:
  • the story is an Epic, i.e. to too big to fit in a Timebox
  • part of the story can’t be estimated
  • part of the story has is higher priority (more value and/or more risky) than the rest
An Epic story is a User Story that is too large to be developed in a single Timebox. It is normal to have a few epic stories in the Release Plan, particularly at Agile Project Initiation, but these have to be split into smaller stories before the User Story reaches a Timebox for development.
Often User Stories include several separate functions. If there is some uncertainty about part of the User Story then cut this part out for investigation. The understood part of the User Story can get scheduled normally.
Similarly if part of a User Story is higher priority than the rest then the high priority element can be split out as a separate User Story for early scheduling.

Defects

Defects need to be logged just like enhancements which means as User Stories. The specifics of how teams do this varies. You have a choice:
  • Log each Defect as a User Story
  • Batch up several Defects as a single User Story
You then have the choice of scheduling the Defect User Stories like other User Stories or of having a reduced Velocity to cater for doing Defects. I tend to do the latter.

Where to Keep User Stories

Most commonly User Stories are written on index cards and are then pinned to a board. This approach has several advantages:
  • It keeps the descriptions short
  • It is cheap and easy to update existing stories, write new stories and/or discard outdated ones
  • Anyone can write one, which gets everybody involved in planning meetings
  • The board and the User Stories it contains becomes the focal point of discussion in the team
There are many Agilists who are happy to leave the User Stories on index cards but I prefer to have duplicate systems. Three in fact:
  • As index cards on the board
  • Titles and estimates in the Release Plan which is usually a spreadsheet.
  • the titles at least in a task tracking database.
There is an overhead to this but the different formats are for different reasons and I could never quite eliminate any one of them.
My Release Plans are always in a spreadsheet. Not only does this allow me to do some calculations on the data it contained (e.g. levelling team scheduled user Stories and Velocity/capacity) but it also means I can email the document to my customers. It is hard to email index cards.  If I had a specialist Agile project management tool such as VersionOne, Mingle, ScrumWorks, etc, I would consider abandoning the spreadsheet.
I also use a task tracking database containing the the tasks for each story. This facilitates sending out emails to individual developers and to the team as a whole, allows me to generate automatic release reports for the operations team and my customer, and gives us a history of what happened when which is important for support. Those specialist Agile project management tools (VersionOne, Mingle, ScrumWorks, etc) are ideal for this but there are other ways to achieve the same effect. At one company we just modified our call tracking system to be the task tracking database. Some of the other Agile teams I’ve managed prefer using a fault tracking database to the specialist tools because the fault tracking database has hooks into their source code repository (specifically Trac and Subversion).

Supporting Documentation

User Stories are not the only information on requirements. User Stories are a place holder to a conversation between the Product Owner and the Agile Team and/or to supporting documentation. If the Agile team doesn’t have sufficient information to estimate the work involved then the User Story needs further elaboration. In such a situation the Product Owner must provide additional documentation or models to help clarify particular User Stories. This documentation should be kept to a minimum but it shouldn’t be forgotten; XP recommends at most four pages of supporting documentation per User Story.
Typically this supporting documentation includes User Interaction Designs (wire frames), visual designs, or a combination of the two in a high fidelity prototype. Financial calculations also warrant being documented separately.

References and Further Readings: 
Beck, K. (2000). Extreme Programming Explained: Embrace Change. Reading, Massachusetts: Addison-Wesley.
DSDM Consortium. (2002). Framework for Business Centred Development:Handbook for DSDM Version 4.1.. Author.
Project Management Institute. (2004). A Guide to the Project Management Body of Knowledge (PMBOK Guide) [3rd Edition]. Author.
Beck, K, & Fowler, M. (2001). Planning Extreme Programming. Boston: Addison-Wesley.
Cohn, M. (2004). User Stories Applied. Addison-Wesley.
Steven Thomas Blog: http://itsadeliverything.com