Trying to “do more with less” is not a new concept in tech. As we’ve seen from the recent rounds of layoffs at prominent publicly traded tech companies, reducing headcount doesn’t always reduce productivity, and can even lead to a higher stock price. The rise of ChatGPT and generative AI has led various tech industry luminaries to say that 40% of knowledge workers’ jobs will be eliminated in the next 5 years. (I strongly disagree with this assessment; I believe AI is overhyped as a solution for software development.)
The truth is that in software development, it’s hard to actually “do more with less.” I have never met a CTO who has enough people and enough budget to do their jobs as effectively as they would like. Many software companies are in a situation where, rather than laying people off, they recognize that good software R&D talent is hard to find. They try to maximize the capabilities of the software development team with the people they have.
Let’s look at a few reasons why it’s hard for tech teams to “do more with less,” and what your company should try to do instead.
Software Engineers are Not a Commodity
The immediate go-to for most CTOs, whenever budget is available, is “let’s hire more people.” Software company leaders tend to think they need more bodies on the tech team to increase developer velocity. But this is often a mistake. Top software talent, especially software engineers, are not interchangeable commodities. You can’t just add “more engineers” to the problem and expect the situation to get better.
At Modularis, our approach and philosophy is “brains over bodies.” The headcount of your software team is less important than how you use the people on that team. The effectiveness of a software engineer might vary by 3-30x from one person to another. Instead of just counting heads, ask yourself:
- How do you get the most throughput and output from your software engineering team?
- How do you get your tech team to be as effective and efficient as they can be?
Beyond adding more headcount, it’s important to take a broader look at the overall makeup, skill sets, experience levels, and culture of your tech team.
Get the Right Mix of Senior Engineer Talent
CTOs often struggle to create the right mix of software talent and resources that they bring into the tech team. When CTOs hire, it’s often under cost and time pressure. So they think, “Engineers are a commodity; I’m going to hire as many engineers as possible.” Often, this means they don’t vet the engineers well enough.
A common mistake is when the tech team has too many junior software engineers and not enough senior people. The flipside could be when the senior people focus only on doing specific, narrow things, and not on supporting their junior engineers. Part of this challenge is cultural. Part of it is due to niches; senior and junior people are used to doing certain things.
A common cultural problem is when an engineer or developer comes in and works on a certain project, but then encounters a problem in the code that already existed. There’s often a culture among engineers of “that’s not my code, so I’m not going to touch it.”
This attitude is often more prevalent among junior engineers, but I’ve seen it among senior engineers too. It usually happens because of a lack of clarity over responsibility in terms of ownership. CTOs and tech team leaders need to push back on this attitude. It’s better for engineers to take ownership – even if it’s code they didn’t write themselves.
Create a Tech Team Culture of Ownership: No More “Hot Potato”
Sometimes, tech team leaders need to say to an engineer, “I need you to spend the time to understand and take ownership of this code, even though you didn’t write it.” Don’t let your tech team perpetuate a culture of “Hot Potato,” where everyone just tries to get problems off their plate as fast as possible.
I recently ran into a scenario where a client hired a junior engineer who was given a project to execute and backfill another engineer who had resigned. This engineer was left to fend for himself. He didn’t have mentorship and guidance, didn’t have deep experience, and was not a “senior” person.
The junior engineer made some common mistakes that people of that experience level tend to make: not enough time doing root cause analysis to find out what is not working. They looked for a quick fix, going on Stack Overflow and implementing a Band-Aid to patch up the problem to get things shipped out. These are symptoms of playing “Hot Potato.”
This is a common cultural problem in software engineering of not taking ownership. There’s a challenge: something isn’t working, there’s a fire. Fires burn hot. It’s human nature to try to get it off your plate as soon as possible.
This results in a great scarcity of teachable moments. At Modularis, we teach our engineers: “If someone tosses you a hot potato, it’s going to burn you, but don’t get rid of it.” Engineers need to grab hold of the problem and truly figure it out. Spend more time analyzing the problem and ask yourself, “What is the right thing to do?”
These are behaviors that can be taught and implemented. To get the most out of the tech team you already have, it’s important to teach the company culture and values you want people to embrace. That’s part of our secret for attracting and retaining the best possible software talent: earn the trust and respect of your people, and they will stick around.
Cultivate Engineering Leadership
Many software companies don’t invest enough in mentorship or leadership training for their engineering talent. More companies need to help their developers become engineers and implement the right engineering discipline to solve the most difficult challenges. You need senior talent to help you maximize the development of more junior talent.
For example, at Modularis, our definition of “software architect” isn’t just people who make pretty diagrams. They are practical, pragmatic leaders who share their knowledge and wisdom with all those they touch.
How Modularis Can Help: Fractional “Heavy Lift” Engineering Talent
At Modularis, heavy-lift engineering and architecture is our passion and focus. We can help bring senior-level talent, on a fractional basis, to your company. We bring a powerful amount of engineering leadership, advice, mentorship, training, guidance, and architectural heft to help your company increase the productivity, effectiveness, and efficiency of your existing engineering team.
The way we do it is designed to help increase and build competency in your own people. We don’t want you to be dependent on us. But you’ll never be able to “do more with less” unless you change your culture and processes – by implementing the right software engineering disciplines, bringing in the right blend of talents, and supporting your team to the hilt.
There are certain crucial decision points within the lifecycle of a software development project. Simply getting the right advice at the right time to help you make the right decision can end up saving you months or years of engineering effort and millions of dollars.
Forget about less. Modularis gives you guidance at the right time to help your tech teams do more, sustainably. When you try to “do more with less,” you can drive teams to the breaking point – you create a “death march.” When a project is under-resourced and the promises are too heavy, what happens? Your best people leave! And the rest disengage and check out emotionally.
Simply heaping pressure on your people and having them work more is not helpful! It’s counter-productive. Instead: work with a partner who can advise you and help you make the right choices at the right times. That’s progress. That’s a force multiplier.
CTOs should stop trying to “do more with less.” Instead, do more with the right team, culture, and processes. Either you hire the engineering talent with the experience to figure this out in-house, or you can work with Modularis. With PlatformPlus®, your dev team can reduce time on software maintenance from 80% to 20%, say goodbye to throwaway code, and spend more time innovating. We can help you do what you need, in a focused way, without hiring anyone else.
Get the most out of your software R&D team without having to throw more bodies at the problem. Download our free Comparison Guide to see how to get a team of senior engineering talent for the cost of one full-stack engineer. Share it with your CEO. Call when you’re ready. See how Modularis stacks up.