Tuesday, January 31, 2023

Best developer as an architect? What can go wrong?

You are working on the application, and there is an idea to move it to a different architecture. It is difficult to convince everyone to take that step, but sometimes you succeed. And then there's a question: who should make architectural decisions? 

Maybe the best people you've got? You want to make it good this time, aren't you? 

Yet, are you sure choosing them is a good idea?

During the years, I saw a few projects that were migrating to the new architecture. The strategies were various, yet there was always the same goal: introduce a better architecture to make some of our existing problems disappear. Ambitious, yet reasonable.

Of course, to move forward, you need to have both people who will make high-level decisions and those who will write the code. Let's take a look at the ones responsible for decision-making. Who would you include?

  1. Your experienced analysts/client representative/product owner/etc.
  2. Testers/client support representatives.
  3. Deployment/Release team representative.
  4. Your most experienced developers.

We need people from points 1-3. They provide input that drives decisions. Let's challenge the fourth group, those whose decisions shape the architecture.

Best devs - why is that a good idea?

The answer to this question can be easy for many of you:

  • they know currently used technology;
  • they know many mysterious places in our application;
  • they know how we do the implementation;
  • they know a lot about the business;
  • they are involved in all/most decision-driving discussions;
  • they are always involved when we need to add something new/modify something significant;
  • they are for you when critical issues happen in production;
  • and so forth...

I think you got the point - they proved many times we can rely on them. And they proved they've got experience and know a lot about our product.

Best devs - why is that not a good idea?

Usually, those devs are the ones who are with us for years. They know how things work, and "they are involved in all/most decision-driving discussions" and "they are always involved when we need to add something new/modify something significant". And yet, here we are, we are facing architectural issues. 

Don't you think it is alarming? You want to include the people who were involved in making most (all?) architectural decisions for the last couple of years, architectural decisions of the project whose architecture you want to change. Well, now it does not sound like such a great idea anymore. 

Don't you think if their decisions over the years are correct, you wouldn't have the problem you've got right now? 

Best devs != good architect

Statements from the previous paragraph lead to another argument: your most experienced developer may not have the skills required to design architecture. Additionally, some great developers were never involved in making any significant decisions. Even if the quality of their code is amazing, their bugs solving speed is outstanding, and their technical knowledge is greater than anyone on the team, it sadly does not mean they can design applications well.

Look for the skills you need

I'm aware you appreciate all the effort and even heroic work your best developers are doing. But each architectural decision is decision hard to change. That's why it is important to make sure those who will make those decisions have enough experience and required skills. 


  1. I was working in a project that all architectural decisions were made by developers. I think the key point is they are also responsible for creating this codebase, so they are not keen in taking "an extra mile" for architecture to make it properly designed. Moreover, they simply have no understanding of architectural craft, usually doing some random decisions down the road.
    I believe your perspective is a correct one, and I wish all of us properly managed teams with all the skills necessary.

    1. You just described another potential problem we may have :)
      Yet, it does not mean devs should not make architectural decisions. Me just make sure those who are making them have enough knowledge, skills and experience. We never should blindly follow the approach:
      - let the team make all decisions
      - let the best devs make all decisions
      We must validate if in that group are people who can take into consideration many important aspects ie. people, their experience, app's surrouding, wider perspective, etc.