Posts Tagged ‘Leadership’

Migration Summary

7 January 2011

Over the last couple of weeks I have put together some of my key learning’s from the last nine month, leading the architecture team on a migration project. There were a lot of firsts in this project for me, both from the problem space of the project but also leading a relatively large architecture team. This has been a good change to reflect on the project and take some time to capture these learnings.

By three methods we may learn wisdom: First, by reflection, which is noblest; Second, by imitation, which is easiest; and third by experience, which is the bitterest.

Leading a team of architects presented several challenges one simple problem of having multiple architects but one architecture to document. A simple habit that the team got into which helped develop a culture of knowledge sharing was the Architecture Review Meeting. At the core of the whole project we developing a Reference Architecture to tie everything back to. Last but not least, we used a technique from the agile world called the retrospective to provide a bit of continuous improvement as we moved from one part of the project to the next.

Doing a migration project was challenging, from the start is seemed that migration is just ETL. As the project evolved we soon realised that a migration is much more than ETL. We had to tackle several problems such as migrating a large volume of data. The importance but also the frustration of having to define what would happen on the day. By looking at other migration projects we came across a technique of defaulting rather than exception.

What a journey!


Multiple architects but one architecture

5 January 2011

One problem with large projects is managing multiple architects working on the one architecture. You need to be able to decompose the problem space into chunks that you can assign to individual architects to focus on. Then there is how to document the architecture, do you produce one architecture document or multiple architecture documents.

Unfortunately this seems to be one of those problems where there is no perfect solution. Every way you decide to tackle it you will get to the end and not want to use that approach again because of the issues it introduced. From previous projects there seem to be three logical ways to tackle a problem like this:

  1. Have multiple architects editing the one architecture document
  2. Break the project into domains and write an architecture document for each domain
  3. Have an architect document a domain and then consolidate into a single architecture document

The first problem is defining the domains that people will work on. For the recent migration project I was on we used a reference architecture to do this. Once you have the break up of the problem space you then have to deal with how you tackle documenting it.

1. Have multiple architects editing the one architecture document


  • The architecture of the project is in one document
  • Don’t need to repeat content across multiple documents
  • Easy to identify if there are any gaps in the architecture


  • Complexity of multiple people editing a single document
  • Domains don’t necessarily align to the document sections
  • Different people have different writing styles
  • Hard to track progress

2. Break the project into domains and write an architecture document for each domain


  • Architects are largely self-sufficient
  • Easy to track progress


  • Have to read multiple documents to understand the architecture of the project
  • Some content will need to be repeated across document
  • Hard to manage things like issues, risks, dependencies etc across documents
  • Gaps in the architecture aren’t always relevant

3. Have an architect document a domain and then consolidate into a single architecture document


  • The architecture of the project is in one document
  • Easy to track progress
  • Architects are largely self-sufficient
  • Don’t need to repeat content across multiple documents


  • Different people have different writing styles when consolidating

For the recent migration project that I was on we went for the “Have an architect document a domain and then consolidate into a single document”. We produced a lite version of the architecture document that we called a Solution Brief. This was just a cut down version of the architecture document with only some of the sections. But at the end of the process we were able to just cut and paste the content of the Solution Briefs into the single architecture document.

Look it wasn’t perfect but I think the process was the better of the three. The big learning was to define the domains that people are working on well as if you don’t get this right up front you are constantly addressing scope issues for the domains you have defined.


31 December 2010

On an agile project a few years back I got to experience first hand the retrospective. The project ran one of these at the end of each iteration and it was an easy going meeting over a beer last thing on the Friday. More as an observer I found it to be an effective meeting where concerns were able to be raised in a constructive manner. It was also good to be able to see the effect these meetings had on behaviours on the project with issues in one retrospective becoming a pro in a future one.

On the migration project that I have been working on we hit a junction going from Part A of the project to Part B. I wanted a way to check in with the team and get some feedback on how thing were going. A retrospective format session seemed like the right way to do this. The first challenge I had, was coming up with the right questions to ask, after much searching I settled on the following:

  • What one aspect of this project would you keep unchanged?
  • What one aspect of this project would you change if you could?

We ran the meeting going around the room with each person having to provide an answer to the question being asked. This was to ensure an equal contribution from everyone on the team. We went around the room twice for each question to get a minimum of 2 answers to each question from each team member. After the two times around the room we opened it to the floor for other suggestions.

One criterion I imposed as we weren’t to solve the problem just raise them in this forum. Unfortunately we have a tendency to want to solve every problem. Keeping it to just raising an aspect we were able to keep the session to 60 minutes.

Coming out of the meeting it wasn’t necessary to have a follow-up meeting and develop a 10 point plan to address all of the issues blah blah blah. A retrospective is good in that it provides a check point to look back (retrospectively) at part of the project and get different opinions on how it went. Just taking the time to hear everyone’s thoughts causes a change in behaviour. Doing it as a one-off probably hasn’t caused a huge change compared to doing it weekly or fortnightly but feedback as been positive.

Most waterfall project I have been on do post-implementation reviews (PIRs) the problem with them is that they are usually after the event. It would be good to find a way to incorporate the retrospective into a project while it was running. This may be a challenge for the next project I am on.

Architecture Review Meetings

29 December 2010

One technique I picked up from a colleague that I adopted on my most recent project, was having regular architecture review sessions. We ended up having these twice a week and it was a forum where we could review designs as a team. We were able to extend these sessions to include people like the security and infrastructure architects as well as the design lead for the project.

Being a fairly disorganised person we ran these sessions in the early stages as a free-flowing meeting more as a general discussion. As we progressed to align to project schedules and all that good stuff we were a bit more organised and had an agenda and had a minute taker to capture all those juicy bits of feedback that were raised in these sessions.

I found these sessions to be beneficial for the team firstly we developed a behaviour in the team of bringing designs in the early stages of forming to these sessions. With the varied experiences of everyone in the room there was some great alternatives presented that ultimately helped us come up with a better design. This behaviour was also good in that the team was happy to bounce ideas around in these forums, people have a tendency to take feedback personally but I think we got to the point where the feedback was constructive and in some cases was intentionally sought by the author.

Given the size of the team these sessions also provided a great forum for the team to get visibility of parts of the design being completed by others. If we had not had these sessions members of the team would have known their parts of the systems intimately, but not had a good end-to-end knowledge of the design. As we had a broad audience outside of just the architects, over time as we reviewed all of the components of the design there was a good history built up about how we go to the final design and the interconnectedness of all of the components.

The way the project unfolded people were assigned areas of the design more to meet the schedule than any natural strengths around domains. These sessions allowed the collective knowledge of the team to be harnessed to review the design. So although someone who had a history using ETL tools may not have been designing that component, within the Architecture Review meetings they were able to impart their knowledge on that part of the architecture.

Having picked this up and applied it to my first project it is definitely a habit to instil into a project of any size. Look for that balance between a free-flowing discussion and a regimented meeting that runs to an agenda. Get that balance right and you create a great forum where the behaviour of the team as a whole can be fostered to build a high performing collaborative team.

Reference Architecture

23 December 2010

I have had the pleasure of leading a team of architects recently on a migration project. What seemed like a small problem but quickly became a real leadership challenge was dividing up an architecture across multiple architects. I have been on projects with multiple architects in the past but this was my first time leading a team.

In the past on projects where we have had multiple architects, we have used one of the following ways of dividing up the work:

  • Assign a domain to each architect and write an architecture document for each domain
  • Have multiple people working on the one architecture document

For this project we ended up going down a slightly different path and came up with something that I will definitely put in my back pocket and use again. To start the process off we came up with what we referred to as the reference architecture. This was a high level component based view of the architecture. The example of a reference architecture below was evolved by an architect taking a component or service and doing the next level of design for the functions identified.

Despite the reference architecture giving us a great high level component based view of the architecture one of the challenges it presented was providing guidance on what each components did and didn’t do. We spent a fair bit of time putting together a pack that went with the reference architecture diagram to outline for each component what was in scope for it and what was out of scope for it. Despite out best effort we still ended up having quite a few discussions about areas of the architecture and what component was responsible for this. Just something to be aware of if you follow this approach.

Once we had the reference architecture in place we were able to assign services and components to individual architects. To go with this we produced a light architecture document that was completed by the architect and then formed the basis of a review process. The document captured:

  • Problem Statement (from the pack described earlier)
  • Context (Highlight the component on the reference architecture)
  • Issues and Risks
  • Logical View
  • Integration View
  • Dependencies
  • Alternative designs considered

Once all of these light architecture documents were completed the content of all of them was cut and pasted into the central architecture document for the project. This was a relatively painless process with things like standardised modelling and content making it much easier.

This process evolved but looking back on it, it definitely provides a different approach to firstly developing the architecture and secondly managing the workload of a team of architects.