4 Reasons to Let Your CEO Choose Your Tech Stack

Photo by Alexandre Debiève on Unsplash

The choice of tech stack is often made entirely by your CTO or other engineering leadership. Though their opinions should carry weight, the CEO’s should carry a lot of weight as well, as there’s often not enough attention paid to the business impact of the chosen tech stack.

Admittedly, this article title is hyperbole, but it remains true that understanding how your choice of stack positions you and your business is very important.

I’m intentionally not considering the technical merit of each tech stack in this post, since there are plenty of resources doing that already. If we were considering only technical reasons, I personally would love nothing more than to write everything in Rust (even on the frontend!), but I’m putting those feelings aside today (and that may not be entirely realistic anyway).

Why It Matters

Your tech stack conveys a lot about your engineering culture to potential new hires, customers, and partners. Just like there are many ways to have very different but equally successful company cultures, there are no right or wrong answers here, just different approaches.

The following attributes are a good way to look at each potential tech stack from a business and positioning viewpoint.

Perception

Every technology has a certain perception in tech circles. How deserved these perceptions are is a topic for endless debate, but the point remains.

Generally speaking, languages/frameworks fall into these broad categories of perception:

• Old / Not Cool — Languages or frameworks that have been around a while and most engineers would not recommend for a new project. Examples: PHP, jQuery, ColdFusion.
• New / Cool — Languages or frameworks that are “new and hip”. Though this often coincides with actually being new, it certainly doesn’t always (for example, Python falls in this category and it’s almost 30 years old). Examples: Javascript (NodeJS), Python, React, Vue, Go, Rust.
• Corporate — Languages or frameworks that enterprise/corporate organizations use extensively, but have a bad reputation in startup circles. This category is the least objective and should be considered based on your goals as a company. If you’re selling to large enterprises, this may be seen as a boon. Examples: .NET, Java.

Categorizing tools based on whether they’re “cool” or not may seem silly in a professional setting, but that’s exactly what it often comes down to. It’s possible to make an objective argument for some of these things (more on that in the section on research below), but much of this comes down to simple preference.

There’s a lot of room for overlap and disagreement here, as you would expect with something as fuzzy as public perception. For example, is Ruby on Rails still cool or not? Depends entirely on who you ask. Is C++ old? It certainly is in a literal sense, but plenty of people still use it and it’s very actively maintained, so the perception varies widely (and in some fields, like embedded systems, C++ is one of only a few options, so the situation is more unique.)

Engineer Happiness

It’s important for a software company to attract talented engineers, and their tech stack is a part of that. Rules of thumb for attracting good talent and keeping them happy:

• If you’re a startup or small company, your culture likely already trends towards applicants who like challenges and learning new things, so pick an up-and-coming new technology that engineers love (more on researching this below).
• If your culture is more corporate or enterprise (either because you are enterprise or your customers are), then aim for something more corporate-focused that is still modern. Engineers that like working in a traditional corporate environment will likely be more comfortable with these kind of technologies, so you’ll be better aligned for attracting talent. Some examples: .NET Core, Kotlin, modern Java. However, it’s worth noting that many enterprises use technology like TypeScript and Python. This topic is very subjective.

Talent Pool

Here’s an interesting counterpoint to engineer happiness: the cool, new technology that engineers want to work on often has the smallest applicant pool. For example, people really love Rust, but the number of competent Rust developers in your area is likely very small, so it’s probably too far in that direction for many situations. I recommend striking a balance here, for example: people really like TypeScript, and it’s also widely used.

Community

Languages and frameworks tend to attract a community, which in turn shapes the support and libraries available. This affects public perception, as discussed above, but it’s worth considering how this affects your company’s mission. It’s wise to pick a stack with a community aligned to your goals, since that will have a positive effect on available talent and overall support.

The clearest example here is Python, which is widely known and used for data science and machine learning by nearly everyone from Google to hobbyists. For this reason, most people (myself included) will recommend using Python for these kinds of use cases.

Some languages foster multiple unrelated communities as well. For example, C# is primarily viewed as the main language used in modern .NET, so the community is mostly enterprise users. However, it’s also the language usually used in the Unity game engine, so it’s widely used by hobbyist and professional game developers too.

There’s sometimes a regional component to this as well. Go, for example, seems to have cities of high use and other areas with limited use. This can affect your plans for talent acquisition.

Photo by Dan Dimmock on Unsplash

Researching Stacks

Here are a variety of resources and tools I find useful for researching technical stacks:

• Stack Overflow Trends (https://insights.stackoverflow.com/trends) — This is a great tool to look at popularity trends. Be careful of bias here though: Stack Overflow has a very wide variety of activity on it, but some frameworks have other lively support forums which will make them look less used on Stack Overflow. For Example, Wordpress doesn’t look that popular here, but that’s likely because Wordpress developers get help on other sites.
• Stack Overflow Survey (https://insights.stackoverflow.com/survey/2019) — There’s a lot of great info here, but I especially love “Most Loved, Dreaded, and Wanted Languages,” since it gives a glimpse into current public sentiment.
• State of JS (https://stateofjs.com/) — Similar survey data, but focused specifically on Javascript frameworks.
• GitHub State of the Octoverse (https://octoverse.github.com/) — Stats from GitHub about language use. Great for seeing trends.
• Job openings by programming language (Indeed search, etc.) — Searching job boards can show you how many job openings there are for certain technologies, which gives a good glimpse into overall usage of technologies and the likely number of developers in the market.

Research Examples

Here are a few examples of performing research on stacks and drawing conclusions. As always, there are many ways to interpret data, and you and your team should come to your own conclusion.

TypeScript:

• Great upward trend: https://insights.stackoverflow.com/trends?tags=typescript
• GitHub data backs up that growth trend: https://octoverse.github.com/#top-languages
• Generally loved and wanted (and rarely dreaded): https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted
• Conclusion: Great choice for pretty much any new project.

Ruby on Rails:

• Downward trend for many years: https://insights.stackoverflow.com/trends?tags=ruby-on-rails
• GitHub data backs up that downward trend: https://octoverse.github.com/#top-languages
• Mixed, mostly negative sentiment in terms of loved/dreaded: https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted
• Conclusion: Not a good choice for a new project.

Rust:

• Generally an upward trend: https://insights.stackoverflow.com/trends?tags=rust
• But, compared to a popular language, still very low usage: https://insights.stackoverflow.com/trends?tags=rust%2Cjava
• Not in the list of top languages on GitHub, but 2nd in the list of growing languages: https://octoverse.github.com/#top-languages
• Very loved in the developer community: https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted
• Conclusion: Great to keep an eye on, but likely too early to use for most projects.

Conclusion

The factors discussed in this article are often at odds with each other: the latest hotness will likely make your engineers happy, but will also have a much smaller talent pool to pull from. Generally, picking a well-liked, popular, modern language/framework is a safe bet, but it depends on the specific needs of your organization.

This article focuses on non-technical aspects of picking a tech stack, but there are many important considerations, including very valid technical ones. Keep all of the points presented in this article in mind and balance it against the technical merits of certain stack choices.