Commercial Web development has been around for more than 10 years. As an industry, this one’s still fairly young when you consider others that have been around for centuries. But relative youth as an industry is no excuse for not doing better.
Consider the number of sites that are rebuilt for clients every day, and you’ll likely agree that there’s still much poor quality work being done, which affects us all: it means that clients are more wary and less trustful of Web developers. Anything that tarnishes our industry can tarnish all of us individually.
Having tried, trusted and standardised approach to Web development would go a long way to helping avoid the mistakes we all see over and over again. We need a Web methodology. However, finding a methodology that seems suited to Web development is not easy; making it work in the real world is even harder.
As the Development Manager for a team of 20, in the heady dotcom days, this was exactly the dilemma I faced. This article explores the issues that arose from our lack of a decent methodology, and how we as a team tried to resolve them. The result was the successful adaptation of an existing methodology for Web development.
A number of factors combined to force the Web development team to make a change in the way we did things.
First and foremost, projects were constantly going over-time. There wasn’t a specific reason for this; each project seemed to have its own particular issues. In some cases, the client changed his or her mind. In others, our team interpreted the client’s requirements differently from the client’s own interpretation. And for others it was a simple underestimation of the work required to complete the project. Regardless of the reason, the end result was the same: projects that go over-time go over-budget unless the client is willing to pay more. And each late project also impacts new projects.
The more frequently this happened, the worse things got, until we had a situation in which almost every project became high risk and suffered scope creep, generated low staff morale, and was expected to have unrealistic deadlines.
The answer was pretty simple: we needed a better way of doing things — a proven way of delivering projects that met the client’s needs on time, and on budget. The solution would also need to fit in with our organisational culture.
We needed a Web methodology.
Adopt, Adapt or Build Your Own
Once the decision had been made to find a better way of doing things, we realised we had three paths to choose from:
- adopt an existing methodology
- adapt from an existing methodology
- build our own methodology
The development team was divided on this issue. Some members believed we should make it up ourselves; others said we should avoid re-inventing the wheel. It was clear we had to do some research to work out which was the best path for us.
At the time, there were no recognised Web methodologies (although, from recent research it appears that the situation hasn’t changed much). So, for adopting or adapting, we had little choice but to look at the existing software development methodologies.
When we started looking for methodologies, we decided that it was important to know what we were looking for. The first step was to decide on the criteria by which we would evaluate them.
The solution had to be more than just a simple guide, but at the other end of the scale, if it was too big, there was no way it would work. We needed something that was easy to understand on the surface — as both staff and clients had to be able to grasp it — but had sufficient depth to give developers the guidance they needed.
It’s hard to get people to read documentation at the best of times, so a thick document explaining the methodology was unlikely to be effective. Chances were that, if we had a 100-page guide with a 10-page summary at the end, most people would use only the summary.
Anything that cost money would have to be justified; the less money that was required, the better.
Learn PHP for free!
Make the leap into server-side programming with a comprehensive cover of PHP & MySQL.
RRP $11.95 Yours absolutely free
We couldn’t afford to get the methodology wrong. It was extremely unlikely that I’d be able to convince people to go through the process of trying a second methodology if the first one didn’t work.
The solution had actually to work, not be based on theory. There had to be real-world examples of projects to which it had been applied successfully, more than once!
We had two presentations from RUP representatives. The first was a one-hour session, the second a more detailed two-hour presentation. Both times, I was more confused after the presentation than before. I also spoke to a number of friends that had worked with RUP and had positive things to say about the process.
The scope of RUP is extremely broad. It covers pretty much everything in the entire SDLC, which is both its strength and its weakness. I was recently at a conference and attended a session by Phillipe Krutchen, one of the leading authorities on RUP. His view was that the main problem that arose when people tried using RUP was that they tried to use all of it. This was the same advice that I’d heard from friends who had used RUP. It’s large and sophisticated, and the key is to use only those aspects of the process that you need for your project. This makes a lot of sense given that projects often vary and the same approach won’t work in every case.
However, given the context of our team, RUP presented a number of issues:
- RUP was large, complex and sophisticated, yet our team was not! We had some team members who were still learning about the SDLC, and to try to introduce something as complex as RUP would require significant additional training.
- Even though RUP was comprehensive, we would have to review it in depth before we could decide which elements we would apply to our projects. We’d then need to trial and refine the process over time.
- The cost associated with the tools that were required to use RUP (eg. rational rose, requisite pro…etc) was high.
Overall, to implement RUP, or a scaled down version of RUP, appeared to be a potentially complex, difficult, time-consuming and expensive process that had a high risk of failure.
We also received a presentation from a Process Mentor representative. The process itself was more compact than RUP, and therefore easier to get one’s head around. In essence it was a Website with a series of steps, forms and templates that could be used to run a project. We felt more comfortable with Process Mentor than RUP because it was less overwhelming, but it still wasn’t quite right. There wasn’t anything that stood out as a major issue, as had happened with RUP, but regardless, Process Mentor did not feel like the right approach.
Our team included a number of experienced developers who had worked with “home grown” processes from previous jobs with heavyweights such as IBM GSA. We had each of these developers talk about their experiences, explaining what worked, what they liked, and what they’d use again. There were a number of techniques that sounded useful but, when all was said and done, the overall feeling was that we weren’t going to be able to “borrow” one of these in-house methodologies from another organisation.
Why Traditional Methodologies didn’t Fit
There was no shortage of vendors willing to tout their processes and associated tools yet, after many presentations, we didn’t feel any the wiser. Nothing seemed to address our needs. The reasons varied but the underlying problem was that none of the methodologies took into consideration the way things worked in Web development.
In comparison to traditional software development, Web development time frames are often shorter, the experience levels of employees vary dramatically, clients often have a poor understanding of what’s possible, the technology changes rapidly and everything comes down to a single user interface (the browser). That’s not to say these elements don’t exist in traditional software development; however, the limitations are much more pronounced in Web development.
Another issue with traditional methodologies is that they failed to take into consideration the “soft” aspects of software development. A recent study of the most important factors in successful software teams (from Cutter Journal March, 2005) ranked trust as the number one factor and technical expertise as last, out of a total of 17 factors. Nowhere in any of the presentations or literature for either RUP or Process Mentor was trust mentioned; nor were any of the other soft skills that apparently have a huge impact on success.
The short answer was that we couldn’t either adopt or adapt a traditional approach. This left us with the unenviable task of trying to create our own.
We were about to start defining our own process when I came across a lightweight methodology that’s now known as the “agile” movement. The methodology in this case was Feature Driven Development (FDD); some of the other popular agile methodologies are XP, Scrum, Crystal and DSDM. (The details of Agile Methodologies and FDD are beyond the scope of this article but if you’re interested to read more, visit http://www.agile.org and http://www.featuredrivendevelopment.com)
It was pretty clear that FDD was far better suited to Web development than anything else we had seen, so we decided to investigate further to see if we could adopt or at least adapt it to Web development. It didn’t take long for the team to agree to give FDD a go. However, we soon realised it wasn’t a silver bullet.
An Overview of FDD
FDD is an agile development methodology created by Jeff Deluca to:
enable and enforce the repeatable delivery of working software in a timely manner with highly accurate and meaningful information to all key roles inside and outside a project.
For details, review the FDD Overview Presentation .pdf document.
Briefly, FDD consists of 5 clearly defined processes that can be captured in 5 pages. The core of FDD is the concept of a feature which is a clearly defined Client-valued piece of functionality. The processes that make up FDD are structured around defining every element of a project as a feature, then designing and building each feature in an iterative manner.
The high level structure of FDD is captured in the following diagram.
Process 1: Develop an Overall Model
This is an initial project-wide activity with domain and development members under the guidance of an experienced object modeller in the role of Chief Architect.
Process 1 involves the project team creating an object model of the business domain — a model that’s more shape than content. The model is not fully defined with all attributes and methods, as this step is more about capturing correctly the shape of the business domain in an object model — not capturing every detail.
This is a highly collaborative process in which everyone has to work together to create the overall model. It takes an iterative approach. First, the domain expert explains a part of the business domain. The project team is broken up into groups (preferably 3 per group) to model that part of the domain. The groups then present their models and consensus is reached on which to use. This process is then repeated for each part of the domain until everything has been covered. The end result is an overall model of the entire domain.
Process 2: Build a Features List
This is an initial project-wide activity to identify all the features required to support the project requirements.
Creating the feature list is the task of the Chief Programmers involved in the modelling process. The client and stakeholders don’t need to be a part of this process, as they have made their contribution in Process 1. Now’s the time to capture the project in a list of features. This does not require collaboration: getting a group of people involved at this stage would not be productive or constructive.
The key to this process lies in defining the project using the language of the business domain. This means that the client will be able to understand and value each feature, but it also enforces a common language across the project team and reduces the risk of miscommunication or assumptions.
Poor communication is the basis of most problems in software and Web development. The language we choose has a significant impact on how effectively we communicate. There are many techniques in FDD that help to provide meaningful communication. The most powerful of these is encapsulated in Process 2: defining the entire project in features using the language of the domain, i.e. using the client’s language. This might sound simple and obvious, but it should not be underestimated. The focus that this step brings is incredible and affects the project in many ways.
In FDD, everything is described as a feature, which is, in turn, defined as:
<action> the <result> by/for/to an <object>
calculate the total for a sale
calculate the total sales for a cashier
A feature is also defined in terms of size (e.g. more than 2 hours’ work but less than 2 weeks’ work). If a feature takes more than 2 weeks’ work, it should be broken into separate features.
Defining everything as a feature avoids the problems that occur whenever the client refers to a concept in one way, the programmer refers to it in another, and the Project Manager has to continually interpret the two. If the Project Manager doesn’t get the interpretation exactly right, mistakes occur: the programmers think they’re building one thing, the client expects another. Using the same language doesn’t mean the problem disappears, but it reduces the risk of confusion considerably.
Process 3: Planning
Process 3 is an initial project-wide activity to produce the development plan.
This process extends the benefits provided by Process 2. It provides the Project Manager with a means of planning the development phase in a meaningful way for both the client and the programmers. It is completed in conjunction with the Development Manager and Chief Programmers, who look, in particular, at the order in which features will be built, balancing load within the team and providing strategies for delivering early results to keep the client happy.
Process 4: Design by Feature
Process 4 involves a per-feature activity to produce the feature design package. This process is broken down into three steps: walkthrough, design and inspection.
In the walkthrough, programmers familiarise themselves with what they’re about to build before starting on a detailed design, which is inspected before they start the build. The inspection of the design allows defects to be found and removed before a single line of code is written for that feature.
It might seem like commonsense to design, and inspect that design, before building, but this step is often ignored. In many other industries, the idea of building something before it has been fully defined, designed and planned would be considered negligent, yet it happens all the time in Web development. The first reaction of many programmers, especially those in Web development, is to open their favourite editor and start coding. The amount of risk to which this approach exposes any project is enormous. However, the converse can also be problematic: attempting to design everything up-front can often result in “analysis paralysis”.
Exactly how much design should occur up-front is a hotly debated topic amongst advocates of agile methodologies. The approach taken by FDD is clear in the difference between Process 1 and Process 4. As we have seen, Process 1 includes design early in the lifecycle, but it’s not a detailed design. The detail is left to Process 4. Putting the detailed design in this later stage ensures that it is considered at the right time: before the code is written. It also breaks the design down into meaningful chunks, feature by feature. This means programmers don’t feel like they’re spending all their time designing and no time coding; immediately after the design has been completed and inspected, the programmer can start to code.
Process 5: Build by Feature
Process 5 involves a per-feature activity to produce a completed client-valued function (feature).
Process 5 is also broken down into three steps: code, code inspection, and promote to build. As with Process 4, the idea of collaboration and benefits inspections is enforced. What makes Process 5 unique is the final step, “promote to build”.
For code to be “promoted to build” it must be finished. The key to this is the definition of “finished”. A feature is not finished until there is nothing else to be done. The way a Project Manager can test if a feature is truly finished is simply by asking if the work is finished. If the programmer answers “yes”, the Project Manager then asks, “There’s nothing else to be done?”. This question often elicits a different response. It’s not that the programmer is being difficult or misleading, it’s just that, given the chance, many programmers will continue to work on code, tweaking, optimising or trying to improve it ad infinitum. If there’s time to do this, it’s not a problem, but if there’s a tight deadline, the Project Manager needs to focus programmers on getting the project completed. This process is a great way to ensure that focus.
The other benefit of this process is that helps the Project Manager see clearly how much of the project has been completed, and how productive each programmer is. According to Gerald Weinberg (Quality Software Management Vol.1), the productivity difference between programmers can be as much as 20 to 1. The issue is how to assess that productivity. Even though features might range in size from 2 hours to 2 weeks of work, it doesn’t take long for the Project Manager to assess how much work each programmer is actually producing once the variances in feature size are taken into account.
Applying FDD to Web Development
Implementing a new way of doing things is much harder than it sounds. People don’t like change, and even those who say they’re willing to give something new a go can quickly change their minds and revert to the old way of doing things. Because of this, we knew that we as a development team would only get so far trying to apply FDD ourselves. Sooner or later, it was going to affect the project managers and eventually clients. We decided it was better to get everyone involved up-front to increase our chances.
The next step was all about internal politics and getting the key decision-makers on side. As FDD is simple to understand, it wasn’t difficult for people to see that we would be better off if we used this approach. On this basis, we obtained the funding to run a training course. Attending the course were representatives of all the groups that would be affected by a new methodology: developers, business analysts, project managers, a designer and a tester.
At the end of the course, everyone was keen. In particular, the following aspects of FDD stood out as providing solutions for the symptoms we suffered:
- Excellent reporting and planning
- Disciplined and clear
- Risk reduction via:
- iteration of design and build in small chunks
- clarity of requirements
- better understanding of the system to be built
- no wiggle room, as fewer assumptions would be made
We also realised that FDD wasn’t going to be the complete answer to our problems. FDD covered development well but it didn’t address the tasks of gathering requirements, interface design or testing. The things that concerned us about applying FDD were:
- its high reliance on technical leads
- it didn’t deal with User Interface design and build
- it was less powerful on smaller projects than on large ones
- it didn’t cover testing and deployment
FDD was not a silver bullet! In the end, we were going to have to adapt the process to our situation and needs.
Managing the Transition
The next step was to work out how to actually apply FDD to our work. There were many projects in production and we couldn’t simply change our approach midstream. Nor could we expect all new projects to start using the new methodology, as not everyone on the team had had training. We were going to have to take a staged approach to implementing the methodology.
We decided to tackle the problem from a number of angles. Firstly, we would slowly introduce a few of the key aspects of FDD into new projects:
- Define projects using features (customer-focused)
- Plan development based on features
- Implement new team structure, design and code reviews
- Conduct weekly project status meetings
Secondly, we would run an internal test project. Our intranet needed redevelopment and we thought this would be a good opportunity to give FDD a go, as well as a chance to try to work out how to deal with the interface and testing areas not covered. Thirdly, although it wasn’t planned, a developer and project manager that had been through the training decided to use FDD on their next project for a paper merchant.
The intranet project didn’t go well for many reasons, none of which had anything to do with FDD. The project suffered from the same problems that many internal projects face: it lacked buy-in and a dedicated stakeholder. Even though we went through a fairly comprehensive requirements gathering process, the project lacked clarity of purpose. It didn’t matter what development process was applied, that project was destined to be difficult. But what it did indicate is that FDD works best when there are clear requirements to start with.
The paper merchant project, on the other hand, went extremely well. The developer, one of our best, did an excellent job in modelling the domain and the project manager was able to track the project easily. The team experienced some challenges, though. In defining the overall model, FDD uses a modelling technique called colour modelling (as explained in the book Java Modeling In Color With UML).
Normally, modelling is not completed in collaboration with the client; in FDD it does involve the client and, therefore, the client needs to have an understanding of the technique. That doesn’t mean they need to be UML experts, but they do at least need an idea of what’s happening. Explaining this to the client was the only real challenge. With most clients, we anticipated that this would be fairly straight-forward and, once they understood it, they’d actually find it fun!
As the project had a small project team of just one developer, one designer and one project manager, it went smoothly. There was no need to create work packages, assign features to individuals, track progress of each individual, and so on. One of the issues that arose in the FDD post-training workshop was the process’s reliance on the chief architect. This project had only one developer, who played chief architect, chief programmer and developer. This was risky: if he was not good at his job, the project would be in big trouble. However, this is the case with all small projects: if you don’t have a decent programmer, you’re in trouble!
Overall, we saw a significant improvement in the project’s progress on a number of levels, some of which were quite unexpected. The goal was to find a way to deliver projects more effectively, but what we found was that the effect on morale was much more positive. The simple fact that we had decided to improve the way we worked had a positive effect. The team was happier because we were doing something about the problems. The new approach also helped to bring together the different disciplines (development and project management in particular) who had previously not always worked closely. There was a palpable sense of focus and direction.
In terms of projects, there was also an improvement. Although most projects still had issues, the problems were lessened and easier to manage. It was much easier to get a real idea of where each project was at, and how much work had actually been completed. For instance, asking a programmer how they were going with database optimisation can lead to one of many responses, some of which don’t necessarily answer the question the client asked: when will it be finished? That’s not to say that programmers deliberately try to avoid answering questions, it’s just that sometimes the questions are hard to answer: often, it’s not easy to say when something will be finished.
This was a key benefit of the feature-driven approach. When a project is defined in terms of “features”, some of the complexity is removed from the questions the client asks. A feature should require no more than two weeks’ work, so when asked how long it will take the developer to finished a feature (assuming it’s been started!), the developer should answer with a figure between 1 day and 2 weeks. This approach actually helps developers to manage themselves, and avoid trying to make project managers happy by telling them what they want to hear, rather than the truth.
Unfortunately, we were unable to monitor the long-term impact of the introduction of FDD. Within 6 months of the training, the dotcom collapse hit the company and we saw a number forced redundancies.
FDD for Small Teams
One of the main criticisms of agile methodologies is that they don’t scale up. For Web development, it’s often more important to see if a methodology can scale down and still retain its advantages. It’s understood that the impact of any methodology will decrease as the team size drops, and FDD is no different. However, I have been able to successfully apply FDD to small teams and projects, for example, a project that used 4 staff members (a project manager, developer, and designer) 3 weeks to complete. FDD can scale down and still provide value to the Web development process.
The two aspects of FDD that are of most value in small projects are:
- defining the project in features
- tracking the project by features
This seems very simplistic, but it’s that simplicity that makes FDD so effective. Fail to define the project up-front as features, and chances are that the client and team will be on a different page from day one. Usually, this problem will only reveal itself once work is delivered. For small projects, correcting such errors is not a big task, however, a few days’ extra work on a small project can mean a considerable percentage of extra work, and can quickly eat into the profit margin.
Like most things in life, getting started on the right foot is the best way to make Web projects work out well. Using the simple technique of defining the project in features using the client’s language will make a big difference to small and large projects alike.
FDD for Web Development
Since this first application of FDD to Web development in 2000, I’ve worked to refine the process and have come up with an approach that has worked effectively on dozens of Web projects ranging in size from 2 weeks to 6 months. This refined approach uses the core of FDD, but introduces new elements to manage some of the areas that FDD doesn’t cover. Below is a high-level overview of how FDD can be successfully applied to Web development.
Although it is not explicitly stated among the 5 processes of FDD, it is an important that every FDD project has clarity of purpose. This need be no more than a simple statement to define what the project is, and what it’s supposed to achieve.
This might seem like a redundant element of a project. The organisation’s purpose should be clear but, although it might be obvious to the client, it might not be obvious to the developer. Writing a single paragraph that explains why the organisation exists is an important step. Of course, this is often easier said than done; for smaller clients, the purpose is not always clear and this question can sometimes generate a very blank look! Still, it’s well worth the effort to ask, as this knowledge can really help when it comes to the next step of working out the project’s purpose.
Once again, this constitutes a very simple statement, but it’s often much harder to define a project’s purpose that it seems. Most clients have many thoughts, wishes, expectations and desires wrapped up in what they describe as their “Website”. In reality, the work must be defined as a project, with a clear purpose that everyone understands and agrees to. The Purpose should be a clear, concise and measurable statement of the business outcomes that the project is intended to achieve.
The specific objectives of the project must be clearly defined. A series of bullet points is fine; the act of thinking this through and getting the client’s agreement is the most important aspect of this part of the project overview.
Consider this example, which suggests objectives that might be identified for ACME, an auto parts manufacturer:
“The objectives behind the redevelopment are as follows:
- Unify ACME’s corporate image worldwide.
- Build a commercially oriented Website projecting a simple, sharp, professional, advanced and confident tone, and one which puts user-friendliness first.
- Ensure the design of the Website adheres to the ACME Group Website Basic Guide Version 1.0.
- Use the Website as a positioning tool to position ACMO as a technology-driven, leading global supplier of automotive parts, systems and components.
- Provide the ability for ACME to update the site in-house using a content management system (CMS).
Understanding and defining a project’s scope is a challenging task. Once again, clients usually want to include everything and expect everything to be done for them. I’m not bad-mouthing clients — anyone who’s familiar with the concept of scope creep will understand my point here.
The key is to get an idea of what’s in and what’s out of the Website. I recommend the use of a technique that was defined many years ago and states simply what’s in, what’s out, and what might be considered. This is a great tool for getting clients to understand all the elements involved in a project. Here’s how it might appear for our fictional ACME auto parts business:
Once again, this is an important consideration. Many sites are constructed without proper regard for the target audience. To say that a site is aimed at the client’s customers is not enough. We need to understand the demographics of that customer base and if we have to target one part of that customer base, we need to know which one it is.
In reality, most sites have a number of target markets that need to be addressed. What proves to be a more practical approach is to think of it in terms of primary, secondary and tertiary target markets.
The main difference between traditional software projects and Web development projects is the nature of content. Most Web projects entail a large amount of content. A Website may be an application or a hypertext system (eg. pages of content). Most projects are a combination of the two, in which case both aspects must be addressed. For projects with a large amount of content, information architecture and design become important elements of the project’s success.
In its most simple form, information architecture can be thought of as a sitemap. IA is the logical structuring of content to suit the purpose of the site. Although this seems like a straight-forward task, the importance of this process should not be underestimated.
A well-structured site will be easier for people to use, and will be much easier to maintain. A good example of a poorly architectured Website is one in which users quickly turn to the search facility to find the information they want.
Most people now understand the concept of a site map and many can put a reasonable one together. The next level, which is far more sophisticated, is to look at the design of information on the page: the information design. The current trend is towards the three column layout with a header and footer:
This is where features come into play, and where the “application” aspect of the Website is defined. The key is to break the project into chunks of work that can be captured in the client’s language, and to ensure that each “chunk” totals between 2 hours’ and 2 weeks’ work.
Features that may be required for the ACME site (each requiring no more than 2 weeks’ of work) include:
- Subscription facility
- Distributor search
- Product search
- Feedback form
An integral part of FDD is the weekly report, which I’ve adapted for smaller projects. In a larger FDD project, the report would provide details of how many features had been started, had not been started, were in progress, had been finished, and were late. From this, an accurate “percentage complete” figure can be derived.
In small projects, it’s not always necessary to go to this level of detail. However, it is important to track progress and report this to the client regularly. I recommend doing this in the following two ways.
A Daily Wrap is a daily meeting with your team. It’s a common task among agile processes. For example, in the Scrum framework it’s called the Daily Scrum or Daily Stand Up Meeting.
In this short meeting, each person states what they did the previous day and what they plan to do today. The goals for this meeting are to:
- make sure no-one is falling behind
- make sure everyone knows what the rest of the team is working on
- ensure that any barriers or problems are raised and overcome quickly
- help foster collaboration within the team
From a project management perspective, the Wrap is an extremely effective tool to keep developers on track. When people promise to do something, and they know that tomorrow, they’ll be asked in front of others whether it has been done, accountability results. The Wrap certainly makes team members think twice about what they promise, and about not following through! Also, the Wrap has a strong social aspect, which makes a huge difference to team work.
The key here is to provide the client with progress updates on a weekly basis. There are many reasons for this, the first of which is to provide the discipline necessary to allow the project manager to review the project on a high level. The progress report doesn’t need to be complex or comprehensive; it simply needs to state what has been done and if there are any issues that need to be resolved. I use the following template, which has proven to be very effective.
What has been completed in the past week? This section helps to generate a sense of progress and satisfaction.
This technique is valuable in helping get things done. Often, the dependency is something the client has to deliver. By putting this down in writing, you make clear who is responsible for delays.
I can’t stress enough how important it is to clearly state any assumptions you’ve made. If they’re not stated openly, they can often cause major issues. For example, a developer may assume that data provided will be in a tabular, delimited format that is easy to import; the client may deliver it as a Word file, or worse: in a graphic format such as Quark or Pagemaker. Document all assumptions!
Every project has issues, which need to be captured in a written issue report.
Hopefully, as the project progresses, the issues that are raised are resolved. It’s good form to capture those resolutions so that, should questions be asked down the track, you can always go back to the resolution noted on the progress report. In particular, this helps with clients who have a habit of changing their minds.
This is a large part of all FDD projects and, in those projects, is called the KMS (Knowledge Management System). All information for the project — all documentation, meeting notes, progress reports and so on — should be captured in an online location that both the project team and client can access at anytime. This helps to ensure consistency by placing all information in a central repository.
There is still no silver bullet!
Adapting FDD for Web development goes a long way toward addressing many of the issues that arise in Web development, but it is not a complete answer. Areas such as requirements gathering, visual design, testing and deployment aren’t covered even though they are needed for every project. But, given the lack of viable Web methodologies out there, having something that is effective, albeit incomplete, it is a big step forward.
Jump Start Git, 2nd Edition
Visual Studio Code: End-to-End Editing and Debugging Tools for Web Developers