Recently I wrote an article about autonomy in a nutshell. It is based on setting up boundaries of responsibilities between teams and based on trust into others that they know how to deal with their own issues the best. This entails that they do receive right to make decisions regarding their areas of responsibility in order to fulfill their goals.

But what exactly such an autonomy might pertain to in real world for each side?

Technical side is responsible for implementing solution that works correctly according to the provided requirements.

Business side is responsible for providing business requirements in a shape that allows to begin working on implementing the solution.

Both sides need to cooperate and trust each other as they have the same goal to achieve which is solving business challenges.

Therefore developers are going to make decisions regarding

  • Technologies to be used that will enable to provide solution that will be easy to write, test and maintain
  • Code readability – if it needs to be enhanced. Only the team members are able to decide if given piece of code requires more time to increase it’s clarity, as otherside time to deliver correctly working solution (or its parts) will be delayed due to increased probability of defects (or number of defects has already been found)
  • Code testability – it’s the developers who knows if there are missing test scenarios, which require corrections and extensions by missing test cases, so that once the code is extended by new functionality the one that already exists still works correctly won’t be not broken.
  • Code reusability – here a simple quick question is enough : Is it easier and faster to reuse small piece of code or so called “eight-thousander” piece of code? Moreover once we reuse such a small piece of code that works then most likely it still works when called from a second and third place! This means that developers should “extract” the functionality that is needed again out of existing functionality rather that write it from scratch.
  • Code extensibility – once code is readable, testable and reusable – most likely it will be easier to extend by additional functionality, especially without re-writing it from scratch as most likely parts of requested functionality already exists.

Business analytics make decisions regarding

  • Scope of works – what should be implemented. The analytics have the best knowledge what business functionality their client needs as it is result of cooperation with the client and their investigation.
  • Sequence of works – the client should receive at least part of working functionality as soon as possible. This allows them (and analytics) to assess if it fulfills the requirements and moreover if what was requested solves the customer problems. If not it’s analytics duty to help in figuring out what changes should be done to the the plan (as we are agile!).
  • Usability of what was implemented so far. Maybe the product is implemented according to the requirements but once customer starts using it it might turns out that something else is needed instead and plans need to be adjusted again.

Besides the above there is some more that is needed in order to succeed : cooperation and trust that the other side makes the best decision according to currently possessed knowledge.

Once in the above scenario by working together and allow we can lead the project to a success.

Spread the word. Share this post!