It's time technology organizations adopt shift left culture

The R&D departments of modern technology organizations - startups and enterprise companies alike - are, by definition, the core of the business. As developers become highly sought-after and prized employees, the kind companies fight over in never-ending bidding wars, smart executives need to find innovative ways to hire - but more importantly, retain - the cream of the crop.

Developers want in

Practically all of the good developers I know have one thing in common: they like to be a part of the process. Sitting idly by while someone else makes the decisions and dictates the “way things are” is intolerable for them in the long run.

A key example of why this is true can be found by looking at current software industry trends. In the software security world, for example, cybersecurity solutions that used to target CISOs/CIOs now target developers - providing them with developer-first power tools that allow them to “own” the security of the product they’re building.

The same happens in the software operations world. The implementation of various practices, like CI/CD pipelines and the cloud-native approach to building software, has armed developers with unprecedented access to - and by extension, control over - the systems that run their software.

Opening the “business gate”

It’s actually surprisingly easy to push your team in the right direction. Your developers are already such a core part of the team - it’s mostly a matter of opening the right doors for them in the right places.

A few examples of areas where your developers would be happy to chime in:

Taking charge of R&D processes - It’s really tempting to micro-manage the internal processes of the most expensive department in the organization. By letting developers design the on-call process, or enabling them to define various needs and decide on appropriate tooling purchases, you’re letting them create their own work environment.

Taking part in product decisions - Technical product managers have their place at the head of the table, but extending the scope of decisions each individual developer can take increases ownership by an order of magnitude.

Customer-facing work - Pre- & Post-Sales engineers see your customers on a regular basis, but the people who actually write the software they’re selling and supporting rarely do. One way of shortening the feedback loop is by allowing developers to spot problems and inefficiencies in the process in real-time - by interacting with customers and joining at least some of the process.

Shifting left your organization

There’s a well-known concept in software development called the SDLC - the Software Development Lifecycle. It’s a way of depicting the various stages of a software development project, with most of the “left” side of the diagram consisting mostly of development considerations, while most of the “right” side consists of various “production” considerations (i.e. the things we do to actually deploy the software and deliver it to our customers).

Many software organizations see the two disciplines as existing in separate silos. There are people who do development tasks, and there are people who do production tasks - two professions, two teams, two distinct sets of processes. However, the increasing demand from customers for better software that is delivered in shorter time frames is already showing that this divide is inefficient (to say the least).

As long as developers are not involved - at least partially - in running the software they write, there is always going to be a significant portion of the stack that is abstracted away from them. My own experience (and the experience of many of the smart engineers I worked with in the past) shows that this is a major problem when trying to break apart tough issues in production. As the saying goes - you don’t know what you don’t know, and by leaving developers out of the process of delivering the final product, you’re (unnecessarily, if I might add) adding extra pressure to the system.

“Shifting left” is the process of taking a set of tasks (or a whole discipline) that is traditionally on the production side of things, and handing the reins to it over to developers - a trend that is rapidly becoming a de facto standard in technology enterprises. Companies like Snyk shift security to the left by giving developers tools to write safer software, while companies like JFrog do the same for the operational aspect of releasing software out to the world.

By choosing to give your developers ownership and more and more aspects of the business, you’re allowing them to feel like they’re part of the equation. Your developers are highly-trained, highly-paid decision making machines - just like your executives; start treating them with the same level of respect.

The author is the CTO and Co-Founder at Lightrun