Dev Centric Culture: Breaking Down the Walls
Break down silos and rebuild your entire application development process around supporting and educating developers.
Join the DZone community and get the full member experience.Join For Free
we have been doing continuous delivery at wix for several years now and as part of that, i have been training my team at the methodology of devops and changing the company’s culture. last week i was trying to explain to some colleagues how we work at wix and about our dev culture. while doing it i realized that we are doing much more than just devops. what we actually do is something i call “developer centric culture” or in short “ dev centric ” culture.
what is dev centric culture?
dev centric culture is about putting the developer in the middle and create a support circle around him to enable the developer to create the product you need and operate it successfully.
before i go into details about dev centric culture and why is it good, let’s look on the problems we have, what we are trying to solve, and why it is more than just devops.
devops is about breaking the walls between developers and operations, but after a few years of doing devops and continuous delivery we realized that devops is just not enough. the wall between developers and operations is just one wall out of many. if you really want to be agile (and we do), then we need to break down all the walls.
let’s take a look at a traditional development pipeline.
- product that “tells” engineering what they need to do.
- software architect designs the system and “tells” the developer how to build it.
- developers write the code (and test it if they do tdd).
- qa checks the developers' product and cover it with more tests.
- operations deploys the artifact to production.
so what we have here is a series of walls. a wall between the product and engineering, a wall between engineering and qa, and of course a wall between engineering and operations. sometimes there is even a wall between the architecture team and developers.
when a product manager hands over a spec to developers, the developers usually don’t really read the whole spec, they misinterpret the product manager’s intention, they lack the product manager’s visions, and they are also disconnected from the client’s needs.
when you have a team of architects doing all the design and telling developers what to do, you again have a wall because developers might not understand the system’s architecture and will not build what the architect intended.
when developers hand over their product to qa you create another wall because now qa needs to guess how the system should work, and there is also a shift in responsibility where developers don’t feel ownership and responsibility to the quality of their product.
then comes the last phase, where operations gets a hold of the product and they are responsible for deploying and monitoring a product they know nothing about.
so when something bad happens there is no one who is actually responsible to the product and you start with a blame game.
if the product is not what the customer expected, then the product manager blames the developers because they did not develop the right thing. on the other hand, developers blame the product managers for not defining the product clearly. if there is a bug (god forbid) on production then developers blame qa for not finding the bug, and qa blames the developers for writing a buggy software in the first place. if there are stability issues in production then everyone starts pointing fingers at operations, who do not maintain the product properly; and on the other hand operations blames the developers for writing unstable software.
so as you can see there are many walls in the process that we need to break in order to have better quality.
so let’s see how we can break these walls, and how “dev centric” culture helps us with that.
dev centric culture means that you put the developer in the middle and create a support circle around him or her to enable the developer to create the product you need and operate it successfully.
in a “dev centric” culture the developer is responsible throughout the product lifecycle, from product definition to maintaining it in production.
now if you think about a very small startup the developer is the key, and does everything from talking to customers, defining the product, designing the system, writing the code, and deploying and maintaining it in production. this is also the phase where the startup is the most agile and progresses very quickly. now if the startup succeeds and grows, more people join the company and slowly build walls around the different departments that eventually hurt productivity.
now let’s see in more detail what walls we have that need to be broken down, and how “dev centric” culture can help break them down and improve the quality and agility of the whole organization.
wall #1: product || engineering
when getting a requirement to design a new feature or system, the product requirement is defined by the product manager. the product manager sits with the clients, understands their needs, and translates the needs into system requirements. the problem with that is that the product manager does not write the actual code and design the system. the ones who are doing that are the developers. if developers get a design document, many times they don’t understand the actual customer need, they misinterpret the product manager's thoughts (and between us, they don’t usually read the whole product requirement document). this causes a waste of time because the developers might develop something completely wrong that doesn't meet the customer's needs. if the product manager catches it in time, the developers can fix the application before it gets to the customer, but it just wasted their time because they could have built it well in the first place.
in dev centric :
instead of product manager tell the developer what to do, the developer sit down with the product manager and together they define the product vision. this way, the developer gets to understand the product and the customer’s needs. by understanding the product, the developer will create a much better system that fits the client’s requirements. if we add to that continuous delivery and “lean startup” concepts, the developer is a very good resource to help the product managers define the mvp (minimal viable product) and make sure that no feature is being developed that is not needed.
wall #2: architect || developers
in many organizations, once the product manager is finished with the product definition, the “ball” is in the architect’s court. the architect designs the system and hands the design to the developers to develop the application. in this scenario, the developers don’t completely understand the architecture and may not produce what the architect intended. another side effect is that we treat the developer as a coder and not as a software engineer, thus limiting their ability to cope with the complexity of designing a good product. this also creates a big workload on the architect who now has to supervise the engineering work and make sure they follow the design.
in dev centric
instead of handing the designs to the developers, we need to invest in the developers' growth and teach them how to design a good system. architecture should be implemented by the developers themselves while the architect should become a consultant and a supervisor. there is a challenge here for the architects because in many cases there is not one correct architecture, and the developer might choose a different architecture than the architect would have chosen. the architect should be open to accept a different approach as long as it is a good one, even if it is different from what he thinks. architects should mentor the developers in how to design a system, teach them how to approach a problem, how to analyze it and guide the developers to think about the architecture concerns that developers are not aware of or missed.
by doing this you invest in your team and grow their knowledge, quality and abilities, thus creating a better product and better developers.
do not be afraid let the developers make mistakes. as long as they learn from the mistakes you will end up with better engineers. if architects feed the developers with the answers all the time, the developers will not learn to cope with complex problems on their own and will come to the architect for every problem, thus creating a much bigger workload on the architects.
wall #3: developers || qa
when developers finish their work and hand it over to qa they are being put in a state of mind that they hand over the responsibility of ensuring the quality of their work to someone else. instead of owning the product that they have just written, it is up to somebody else to find their bugs. this case causes developers to not invest too much in the quality of their code and not feel responsible for their own work quality. now when a bug is found in production, the developers believe that it is qa's fault for not finding the bugs.
in dev centric:
the solution for this problem is really simple. you need to make your developers write tests and be responsible for their own work. the only way to do that is to start doing test driven development. developers who work in tdd write better code and their designs are much better because it has to be testable, with the right abstractions and separation of concerns.
now for developers who are not used to writing tests this can be a challenge, but from my experience, once they do that long enough, the developers understand the benefit of tdd and never want to go back to not writing tests.
developers should write both unit tests and integration tests. for back-end development this is usually enough, no qa is necessary unless in very rare cases where changes are very deep and might affect other systems. at wix the back-end group works without any qa.
now you might think that if developers do their own testing, what do we need qa for. well you still need qa, but qa should change their role. instead of verifying the developer’s work quality they should complement the developer’s tests by writing automated system tests (end-to end) and in some cases do manual qa for ui components during development until an automated test is created for them.
wall #4: developer || operations
in order to deploy the application, the developers or qa hand over the artifact to operations and the operations people install or deploy the application. the problem is that the operations people know nothing about the application, what it does, and how it should behave. now we expect them to install it and also maintain applications that they are not familiar with.
in dev centric
the developer should be responsible for their own applications in production. the developer should install and maintain the applications with the support of the devops engineers. devops engineers should create the tools to help the developer install and maintain their applications on production. while developers should have ssh access to production, ops should create the tools so that developers will not have to ssh to production.
make the production environment visible in a developer friendly way. via a monitoring system and easy access to logs (log aggregation), developers should see how their system behaves in production at all times. this creates a better quality product because now the developers are also responsible to their work in production. every time there is a problem in production, the developer should be alerted and handle it in production with the help of operation engineers.
wall #5 developer || bi
we see bi as a business concern and generate reports to marketing and management, while the developers are not exposed to most of them. this creates a lack of knowledge of what is going on with the system and how it is used by the customers. if the developer does not know how a system is used they will not be able to make improvements on the parts that really matter.
in dev centric
expose the bi reports to the developers. make the bi tools accessible to developers so they can add technical data and take advantage of bi analytic tools to understand how the system is used. by doing that, the developer can have a sense of priorities and knowledge of how the system is used in real life. once developers understand that, they can make improvements and optimizations to the most heavily used parts of the system and by doing that, help customer satisfaction.
maintaining a dev centric culture is not easy. you put a lot of responsibility in the hands of the developers. you actually give all responsibility to the developers. but if you think about it, this is exactly what you should do. the developers are your company assembly line, they are the ones who actually create the product. they have a direct impact on the company’s success and bottom line. by understanding that and entrusting the developers with the power to change and take critical decisions it is a win-win situation.
remember developers can do the work of a product manager, architect, qa and ops, in fact this is exactly how a small startup succeeds, because developers actually do all of it.
what do you think is it time to go back to the future by breaking all the walls?
next chapter: dev-centric trust and collaboration
Published at DZone with permission of Aviran Mordo. See the original article here.
Opinions expressed by DZone contributors are their own.