The Agile Practitioner: Agile Documentation

Agilists have had an ongoing struggle with documentation. Whereas process practitioners have strong methodologies for providing detailed, structured process documents, the agile manifesto casts documentation in a dim light with these two principles:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation

The agile progenitors were trying to make a point here, but as is so often the case, people overreacted. They took this to mean:

  • Have a conversation
  • Write some software
  • See what happens

This has been tried many times. We have learned that this is NOT the most efficient way to build great products. Ironically, writing software this way is still much more efficient than back when teams would write “complete” documentation of what a final product would do and how it would do it before writing a single line of code. This approach is called “waterfall” and when it was abandoned for agile software development, there was a strong backlash against documentation.

Early adopters of the agile approach did have documentation. While Scott Ambler was not an original signatory to the agile manifesto, he was most certainly a pioneer in the area of agile design, in 2002, the same year in which the manifesto was signed, he published Agile Modeling: Effective Practices for EXtreme Programming and the Unified Process, in which he described a structured approach to designing software without the heavy load that preceding methodologies tended to invoke.

Other tools like the Booch Method, Rational, and unified modeling language (UML), were and continue to be valuable in creating design documentation. However, because these tools preexisted agile practices, those familiar with them had a tendency to use them the way they had always been used — to develop complete system documentation.

In fact, the nature of these tools lend them to just such practices. They are effectively pseudo programming languages that allow you to define system functionality at a somewhat higher level. Naturally, designers use them to define system functions and workflows.


What Ambler did by moving away from these tools is propose a design methodology that did not rely on a strict definition of how the software would be built, but rather begin the focus on who the software would be built for, what they needed it for, and how they might use it. He introduced the concept of just in time (JIT) modeling of system functions starting with the highest priority work as illustrated in his diagram below.

In the ensuing years, additional types of documentation have evolved to address parts of the product design process that precede modeling system functionality. The reason for this became clear when broader aspects of the project didn’t go well, such as not solving the right problems or not having the right resources available to properly understand the users’ needs.

The Start

Nowadays, when we start projects of any significance at ITHAKA, we develop a document called a Project Execution Framework. This document is structured as follows:

  1. General Purpose – this is a basic statement of why we have chosen to do this project now. Some of the statements here will be elaborated in subsequent sections. This is similar to an executive (or TLDR) summary.
  2. Goals – this section is an elaboration of the expected achievements of this project — the specific outcomes.
  3. Talent – here, a list of specific people and the roles they will play could be listed, or it could include a list of specific skills (with expressed or implied roles) that will be needed to successfully complete the project.
  4. Accountability – if this is a single team project, this section will specify individuals who will be the focal point for maintaining order and sustained progress around certain aspects of the work. If this is a multi-team effort, while individuals could and should be named, teams’ responsibilities of ownership around various aspects of the work are also identified.
  5. Impact – while goals define the outcomes of the work, Impact defines the nature of the sustained effects either to the organization internally or to external stakeholders. For example, the goal might be to save some money, but the impact may be that the organization frees up operating capital to execute another crucial project.

What the Project Execution Framework brings is clarity in a brief and succinct way (these documents are rarely more than three pages long) to all of the project’s stakeholders up and down the organizational hierarchy. It can expose challenges and gaps that may not have otherwise been considered until the project was well underway. Exposing these things early can inform “go, no-go” decisions or suggest a pivot that may have otherwise not been considered.

Discovery Phase

In the beginning of a project, the team must assess their existing knowledge of the domain in which they are developing. Most teams already have significant domain knowledge. However, if they have prioritized changes to a particular aspect of the product, it is likely that their existing knowledge is or was suboptimal. This is either because they didn’t understand user behavior, user behavior has changed since the last development cycle, or technology has advanced enough to make the existing implementation out of date. Of course, it could be a combination of these things.

The first step is to understand these knowledge gaps and the best way to do that is with research. Good product teams will gather as much evidence as possible before making decisions about what direction to take. This is where the agile development approach really shines. The reason for this is specifically because agile methodologies do not dictate intrinsic processes and or technologies (as noted above). This frees teams to use whatever tools serve the purpose.

When we interview users, observers use a Sharpie™ to jot their observations down on Post-It™ notes (we’re apparently very particular about our brands). Our user research team member would then consolidate these notes into a document. Back when we used to work in an office, our conference rooms had whiteboard walls. We often took notes on these walls and used our phones’ cameras to capture and save the notes.


This practice allowed us to work through our collaborative discovery process and create documentation in a frictionless manner. While these documents were not always beautiful, they served their purpose well. Since leaving the office to work at home, we have relied on tools that simulate our beloved walls and in some ways improve on them.

One such tool is Google’s Mural. Another similar tool is Jamboard. These tools have the added benefit of having templates and built-in features like post-it notes. The point here is to capture knowledge as the team gains it in a way that maximizes sharing, while retaining it in some manner for reference as needed.

Building It

Having learned what we can, there comes a time at which we must take the knowledge and understanding we have and build a product. This is where Ambler’s approach is particularly effective. We almost always start with a high-level representation of the workflow or system architecture that we want. Whether you use your favorite BPMN modeler or the myriad other options available for graphic modeling, what matters most is that there exists a reference model to provide a common conceptual understanding.

Agile teams keep these types of diagrams in perspective. They understand that the deeper they get into the details, the greater the probability that their learnings will take them in different directions. We often talk at the beginning of a project about a concept used at NASA and later popularized by Donald Rumsfeld. There are known unknowns – the things we recognize as gaps in our knowledge that we plan to fill out as we go (in this regard, the discovery phase never really ends). We also have learned to expect unknown unknowns – things that will impact us, but we have yet to gain any awareness of.

Attempting too much detail upfront is wasteful. Assuming that you have detailed work that will occur much later in the project, the probability that your initial designs will survive intact are low. Furthermore, they could color the team’s decisions when the time comes to actually implement these features or functions. It is far more efficient to document the work just before it is needed because at that point you know all that you are going to know before starting.

Even here, design documentation should be very lightweight. Business analysts tend not to like this lightweight approach too much. In fact, I was rather surprised to discover when I joined ITHAKA that most of our teams don’t have a business analyst. I wondered how this would work, but our lightweight approach combined with the expectations that every member of the team will have an understanding of our business stakeholders and their needs, lends itself nicely to successful outcomes.


We use Jira, which is pretty common among software developers. Another common tool is Trello, which was recently purchased by Atlassian (makers of Jira). What these tools allow us to do is break down the work, prioritize it and put the documentation we need to build it inline with the very tool we use to manage our work.

We have a wiki that we use to document technical information for new team members and other teams that may need to integrate their products with ours. Wikis can be very useful, but deciding how to use them before you start is very very important. Tools like Atlassian’s Confluence and Microsoft’s SharePoint are the most popular in this category. The challenge here is that to use them effectively, it is essential to decide on two things prior to implementation:

  1. What types of documentation will live in the wiki
  2. A well-defined information architecture

Skip either of these steps and what will ensure is an uncontrolled mess. Furthermore, no wiki will maintain itself. Information becomes outdated and unless it is either removed or updated, even the search function won’t necessarily yield useful findings.

Therefore, we tend to put two types of information in our wiki:

  • High-level architectural documentation that is relatively static
  • Theoretical information for other teams to understand how to utilize the components our team provides to them

That second type of information gets tricky because we generally prefer to put the most technical information for users of our work as close to the source as possible. So, documentation for developers who may be working on the code will generally be found inline in the code or in the readme file in our code repository. If we are writing application programming interfaces (APIs) for other teams to call, we will write the instructions into the endpoint management tool, such as Swagger.

There’s an important distinction here and it can best be illustrated by the evolution of software itself. Once upon a time, software came with an instruction manual. People had to “learn” how to use it. Nowadays, we expect it to be so obvious that anything more than a tooltip (those little pop-ups that we see when we hover over something), would be considered an indication that the application was poorly designed. In the same manner, the software code itself is now expected to be essentially self-evident, such that other developers can read it and easily see what it is doing.

A great example of this is in variable names. Long ago, variable namespaces only allowed for eight characters so names were often cryptic (e.g. usrhmadr). Now, these restrictions don’t apply so developers use long descriptive names that make it obvious what it is (e.g. UsersHomeAddress). Similarly, user defined program functions will have long descriptive names like StoreNewUserContractRecord. If the next developer to come along can’t figure out what that does, they’re probably not fit for the job.

That’s a Lot to Remember!

This diverse set of tools seems like it adds more complexity to the process of documenting our work than is necessary. In fact, the diversity comes from a de-emphasis on documentation. The tools are there to support the natural collaboration that takes place between people on the team, between teams, and with end-users. Our objective is to have as little documentation as is necessary to produce great products for our users. While the choice of tool for a particular purpose is not inconsequential, it is indeed based on the needs for that particular purpose.

Some documentation has a very short half-life and the place where it lives need not be overly organized because it is likely to never be needed again after a relatively short period of time. Other types of documentation will be used for reference for many years. We always try to put the documentation as close to the point of use as we can. So, more theoretical documentation may go in a wiki, but more technical documentation will be right there where people will be when they realize they need it.

Finally, there is the documentation we don’t write. Any time we can make something so self-evident that documentation is not required, we will choose this option. Some call this “self-documenting.” Whatever you call it, you can rest assured that more thought went into it than the solution that requires a lot of explaining.

If there’s one takeaway here, it is this: don’t standardize on one or two tools and make everyone fit their use to it/them. Allow people to find the tools that fit the need. It may cost a little more to maintain additional documentation tools, but the net result is more productive staff and better outcomes, and I can almost guarantee that the cost/benefit of that will far outweigh the cost of the extra tools.

PDF Version

Tom Bellinson

Tom Bellinson

Mr. Bellinson has been working in information technology positions for over 30 years. His diverse background has allowed him to gain intimate working knowledge in technical, marketing, sales and executive roles. Most recently, Mr. Bellinson finds himself serving as an Agile Coach for ITHAKA, a global online research service. From 2008 to 2011 Bellinson worked with at risk businesses in Michigan through a State funded program which was administered by the University of Michigan. Prior to working for the University of Michigan, Mr. Bellinson served as Vice President of an ERP software company, an independent business and IT consultant, as chief information officer of an automotive engineering services company and as founder and President of a systems integration firm that was a pioneer in Internet services marketplace. Bellinson holds a degree in Communications with a Minor in Management from Oakland University in Rochester, MI and has a variety of technical certifications including APICS CPIM and CSCP.


Leave a Reply

Your email address will not be published. Required fields are marked *