Agile

Is there still room for architecture in an agile engineering organisation? Of course there is. There is a perception that agile teams are self-contained groups of generalists who should be left alone to self-organise and build software. This is true, but development teams still need to make architecture decisions all the time. There does come a point at which problems are too big for any one self-organising team to solve. Some design co-ordination is needed.

Architecture governance is a spectrum: exploring styles of enterprise architecture

8 January 2024

There is a spectrum of different styles of architecture governance, from the tightly structured and framework-driven, through to the deliberate absence of formal architecture.

Establishing a new architecture practice in agile organisations

2 September 2023

How should you go about building an architecture practice in organisations where people are allowed to say “no”? Ultimately, this becomes an exercise in persuasion, pragmatism, and patience.

The shared code fallacy: Why internal libraries can be an anti-pattern

15 July 2023

Most internal shared libraries are based on the fallacy that code sharing always makes development more efficient.

How can architecture improve agility and delivery flow?

2 March 2023

Agile practices on their own are no guarantee of fast flow. You also need a planned architecture that enables team autonomy and supports rapid, iterative delivery.

Can internal developer platforms really be optional?

14 November 2022

Internal developer platforms are supposed to be so compelling that engineering teams will flock to them, but are we givng teams any real choice?

What makes a good test automation suite?

3 August 2022

Writing a good unit test suite is hard. Many test suites don’t provide any meaningful benefits, merely serving as an unreliable and unloved extension of the main code base.

Inner source is more of a cultural shift than a technical change

12 June 2022

Adopting inner source is more than just a matter of putting a project into GitHub and accepting pull requests.

In defence of the Scaled Agile Framework (and other 'branded agile' variants)

17 May 2022

Larger organisations are beset with complexity that can’t be fully addressed by autonomous teams focusing on value. At least frameworks like SAFe recognise this and attempt to offer solutions based on experience.

How should architects collaborate with development teams?

6 February 2022

If we’re serious about empowering engineering teams to make decisions, then we should be embedding architectural skills rather than architects themselves.

Prototypes and the myth of disposable code

3 August 2021

A lean approach suggests that features can be proven in quick prototypes before being implemented ‘properly’. Alas, things don’t always work out that way…

Why the developer experience matters to architecture

17 April 2021

Architects have a key role in setting the direction of travel for development, giving them an opportunity to help foster a good developer experience for an organisation.

Setting an appetite instead of making an estimate for epic-level work

8 January 2021

Estimates are difficult, usually wrong, and frequently misused, especially at the “epic” level. An “appetite” can be a more meaningful measure that defines the amount of time the business is prepared to invest in the solution.

“Goldilocks” governance and agile architecture: balancing team autonomy and alignment

24 August 2020

There can be a tension between the lean, experimental nature of agile development and the more deliberate, planned demands of a large organisation. It does not have to be like this.

If “Enterprise Architecture” is failing, what should architects be doing instead?

11 March 2020

The discipline of architecture is an important part of any efficient engineering organisation. It just needs to adapt its game from the process-orientated “Enterprise Architecture” of old to something more collaborative and relevant.

Don’t use test coverage as a target

19 February 2020

Code coverage can be a useful technique for discovering untested parts of your code base, but it makes for a useless target.