Micro Focus is now part of OpenText. Learn more >

You are here

You are here

7 skills software engineers can teach CEOs

Steven A. Lowe Product Technology Manager, Google

What skills can software engineers teach CEOs? Obviously, software engineers are logical, efficient, detail-oriented, and organized—and so are most CEOs. But what about the more subtle, even irritating qualities of software engineers? Can CEOs learn from those?

1. Being lazy

Good engineers (not just software engineers) are lazy; they prefer automation to repetitive work, and they're loath to do any unnecessary work. Meetings and paperwork frequently fall into this category. By avoiding unnecessary work, software engineers can be more efficient and have extra time to do more useful work.

CEOs should likewise strive to be productively lazy. Eliminate unnecessary activities, and spend your energy and time on tasks that add value instead. In most cases, there's no point in doing the same thing twice. If it must be done repeatedly, automate it. And if you can't automate it, delegate it!

2. Failing often

Software engineers are part inventor, part scientist—they fail a lot. Often, it's intentional, but sometimes it's experimental. It's not reckless, but it is fearless. Unknowns are risks to be explored, not ignored. Focused experiments and prototypes allow for fast learning.

CEOs can adapt this practice to great effect: to explore new markets, try different approaches, and even investigate trends and hunches. The trick is to fail cheaply, quickly, and with a purpose in mind. (If you think this sounds a bit like Lean, you're right.)

If you're not failing often, you're not trying anything new.

3. Creating problems

Software engineers actively look for problems, and they sometimes even create them intentionally. Problems are opportunities in disguise, and the absence of known problems isn't proof of no problems. Software engineers destroy things to see what happens. They write tests just to make sure all the edge cases work. They implement monitoring systems so they'll be alerted if something goes wrong. Above all, they listen when people complain—because that leads to surprises, which are almost as much fun as problems.

Startup CEOs have learned to do this systematically, exploring the space around an opportunity until they find just the right problem to solve, with the right solution, for the right market, at the right time. Then they pivot and pounce. Established CEOs can do this as well, as a form of continuous improvement.

4. Getting your hands dirty

Software engineers frequently get their hands dirty. They not only work in the coding trenches building things, but they also work with users and customers to try to understand how things really work. The answers aren't in your office; they're on the plant floor and in the customer's office. Take the software-world notion of user experience and see how it applies to your entire supply chain and to your own employees. What you learn from this new perspective may surprise you.

5. Ignoring people

When software engineers are working, they tend to ignore people, especially when they're working to make improvements. Most problems stem from the constraints of the systems in place—whether it's time, money, motivation, incentive, standards, or process—and individuals are often powerless to fix the systems in which they're embedded. Culture, peer pressure, and a bias toward the status quo are powerful obstacles to overcome. Yet to fix things, changing the system is exactly what must be done.

CEOs are used to dealing with political systems and people, so they might have a tendency to assign blame and risk to certain individuals. That may sometimes be the correct approach, but if you look past the people to the system in which they operate, chances are you'll discover that the system is the cause of the problem.

Remember that no system is perfect, and no system is sacred.

6. Killing your darlings

Engineers aren't afraid to put their ideas to the test and discard them if they prove impractical. They routinely "kill their darlings" by abandoning treasured ideas and pet projects, no matter how fascinating, if they don't work. CEOs can do the same, both by vetting their ideas against reality and by objectively evaluating others' performance. (Don't literally kill anyone, obviously.)

7. Staring into space

Software engineers stare off into space a lot, but they call it systems thinking: the ability to see a complex set of interconnected systems as a whole. Systems thinking is arguably the most important (and sometimes the most irritating) catalyst for producing coherence and simplicity from complexity. Software engineers are adept at systems thinking, routinely solving problems requiring them to balance multiple constraints in addition to time, money, and quality. While this propensity can be annoying when deciding where to go to lunch, it's invaluable when tackling significant problems and searching for opportunities.

CEOs have to deal with multiple interrelated systems and conflicting constraints all the time. Examining each piece in isolation isn't enough; you also have to consider all the potential relationships and forces involved. Systems thinking embraces high-level and granular considerations at once, using multiple perspectives. From this, a holistic model can be formed that serves as scaffolding for identifying, organizing, and solving sub-problems. Often a few simple ideas and rules suffice to make a chaotic mess collapse into a crystalline whole.

Software engineers don't get paid to write code; they get paid to think. Systems thinking doesn't happen when you're writing code—writing code is the outcome of that thinking (though sometimes you can do a bit of both at once). So if you see a software engineer staring off into space, and they do it often, that's what real work looks like. Simple, elegant solutions don't fall out of the sky but have to be pursued relentlessly.

Get creative

Set aside some quiet time, and bring all your imagination and creativity to bear on your CEO-level problems. Ponder their intricacies and constraints. Imagine their interacting forces. Examine them from multiple angles. Look for patterns and analogies that may help explain or simplify what's happening or what you want to happen. And when you discover a potential answer to your problems, run a fast, cheap experiment to test it. Then repeat, ad infinitum. Your work, like that of a software engineer, is never done.

Keep learning

Read more articles about: App Dev & TestingApp Dev