Over Architected?

Over Architected?

First off, I am by no means an “Agile” (nor even “agile” with a small “a”) software development expert.  There are many more individuals out there that are way more experienced and in a much better position to speak authoritatively about the Agile methodology and its associated principles on driving efficient and effective software development.  A few blogs where I consistently find great Agile perspectives are included at the end of this article.  But as I’ve participated in Agile and agile-like development efforts over the years, I’m finding an interesting pattern.  Agile and agile-like approaches have a positive by product of reducing the occurrence of over architect-ed software solutions. Over architect-ed solutions put stress on the delivery of a software application project as well as drive up the cost of software development and maintenance, in general, disproportionately to the business value produced.

As an example, a sample development effort starts out with:

Product: “We need a super widget in the product by next release, can we have that?”

Project: “We are going to need detailed requirements for the super widget in order to start developing it.”

Product: “Oh, it needs to be able to interface with the dry cleaners to know when it is time to pick up the laundry as well as make coffee for the customer before they get out of bed in the morning.  Basically the same features as our competitor’s recent release, but with these additional benefits. <Or some other description that is actionable at a high level, but lacks the detailed requirements needed to feed a development team with actionable development tasks>”

Development: “Ok, we’ll get started since we don’t have much time before the code freeze for the next release.”

… Time goes by …

A project status meeting occurs sometime in the future.

Product: “So, where are we with that super widget?”

Development: “We have the basic framework setup but it isn’t going to have all the features working by the next release.”

Product: “But I thought …”

Development: “But you said …”

Project: “What happened?  How come we are X days from the code freeze and we don’t have a viable solution?  I thought …”

Now sure, this isn’t the most perfect example of capturing how the requirements drift between stakeholders leads into an over architect-ed solution, but hopefully you get the scenario.  Or possibly another example would be when a solution is developed and released into the production environment.  Extending the example above, weeks later, when enhancements, tweaks or feature extensions are requested, a tense conversation occurs around:

Product: “But I thought the super widget would do X?  How come I am hearing it will take 30 hours of development to get X?  The testing cycle is already elongated due to the complexity of the super widget thus I thought it included X?”

Development: “But we said that the framework would support X, but we never said X would actually function without more development!  We developed the super widget to do W, Y and Z but only stubbed out X.”

Project: “But according to the requirements, it says X should be …”

And yes, an argument can be made that if:

  • more effective requirements gathering occurred
  • more effective project management captures more depth of what would be developed and available when
  • more effective product management defines a more exhaustive product feature road map that more clearly outlines what would be available and not available when, feature-wise

… These problems wouldn’t have occurred.  But the nature of an agile-like approach puts a tighter focus on all the stakeholders:

Product: They can share the “overall vision” of what they ultimately desire the product to do, but they are forced to consider what they really need within the shorter duration of the agile-like release schedule.  Thus, product walks away with a clearer picture of what they are really getting in the next release.

Development: They get the benefit of the product’s “overall vision”, yet, they get to quickly dive into the critical features and start the dialog of how long different feature components will take to develop.  Thus, development knows exactly what they need to do now for the next release, yet they benefit from knowing where this product feature is going in the future.

Project: As long as they keep the product and development stakeholders talking about granularly defining what needs to really be built by when, the project management function has much greater clarity into what is going on and what details to track.

From what I am observing, all of the above create a stakeholder forum of information sharing that reduces the likelihood that an over architect-ed application will get developed. Most importantly, instead of leaving the feature set open and vague enough to allow a creative and motivated development team to start building and building and building only to re-surface with a highly complex solution to a loosely defined problem or need, it brings more cohesion between what is really needed first.  Once the “first” has been built, the “seconds” and “thirds” get built inline with the product roadmap.

In researching this theory, I wasn’t able to find any articles that linked agile-like development efforts to a direct reduction in software over architect-ing.  This article entitled “Agile Architecture: Strategies for Scaling Agile Development” had some interesting content on baking architecture into an agile-like effort.

Anyone else have any direct experience in agile-like compared to waterfall-like development efforts yielding less application over architecture?  Can anyone share any links to good web articles on this topic?

Agile related blogs I follow:

David’s Software Development Survival Guide




Software Project Management




Regular Geek


Critical Results


, , , , , ,
  • http://fragile.org.uk Neil

    Have you come across “You aren’t going to need it”? In short “Always implement things when you actually need them, never when you just foresee that you need them.”

    By implementing only the barest necessary feature set in the first instance, you reduce system complexity and save time in the process.

    http://c2.com/xp/YouArentGonnaNeedIt.html offers a good explanation.

    • http://midwestitsurvival.com jfbauer

      Neil, thanks for dropping by and sharing your link. I had not come across “YagNi” and I am in the process of digesting the link your provided. Initially “YagNi”‘s logic in the first page seems pretty sound. I’ll have to read more.

      BTW, I appreciate your insights on your blog, great work! I especially enjoyed your “How to do nothing” article: http://fragile.org.uk/2010/02/how-to-do-nothing/

  • http://blog.criticalresults.com Mark W Schumann

    Hey John, thanks for the plug.

    I’m sure Neil is familiar with the closely related discipline of “Doing The Simplest Thing That Could Possibly Work” (DTSTTCPW).

    Fundamentally, you need a lot of flexibility in your process and in the code itself to make YAGNI and DTSTTCPW practical. When adding a feature is time-consuming and prone to error, you worry about it in advance. When it’s relatively easy, you feel better about writing today’s code today because the (potential) new feature will come along when it needs to.

    That’s also where short iterations come in. If there’s a new release every 2-4 weeks, then it’s safe to delay a feature until you know it’s actually going to be used. If it’s important, you can have it in two weeks or a month instead of six months, right?

  • Pingback: Midwest IT Survival » Is the Gantt Chart Useless in Agile Projects?

  • Pingback: Midwest IT Survival » Managing Infrastructure Compared to Software Development Teams – Part 2