Are Non-CS Major Developers Really at a Disadvantage?

In this post, I want to talk about a question many people have asked me: are developers who didn’t major in computer science really at a disadvantage compared to those who did?

This might be a sensitive topic, but many people around me have asked this question, and some even undervalue themselves simply because they didn’t major in computer science. I think this issue isn’t limited to specific individuals, so I want to carefully share my thoughts on it.

This post discusses fields where non-majors are common - backend, frontend, mobile app development. Fields working at layers lower than the application layer are already difficult for non-majors to enter.

Over the past year, I’ve conducted quite a few interviews. Among the candidates were CS majors, people with completely unrelated majors, fresh graduates, and senior developers with over 10 years of experience.

Let me start with my conclusion: while experience gets considered in some cases, the major itself - whether CS or fly leg dissection studies - doesn’t really matter that much. However, it’s also true that CS majors have various advantages over non-majors, so it’s worth thinking about what advantages the CS major title actually provides.

Also, if you didn’t graduate from a CS program, rather than having vague fears, just clearly identify how you differ from CS majors and study accordingly. University courses aren’t impossible to self-study. And CS majors aren’t some unreachable tier - with study, you can surpass them.

For reference, I didn’t attend a Seoul-area four-year university, and I’m not a CS major either. I studied multimedia engineering at Dongguk University’s continuing education program through the credit bank system, but took mostly CS courses as electives, so I’m kind of a hybrid straddling the boundary between major and non-major. (The multimedia program curriculum itself was basically a jack-of-all-trades factory)

So from this hybrid position, I’ve heard concerns from both CS majors and non-majors, and I want to share some thoughts on these issues in this post.

Companies Look at Skills Over Majors

As everyone knows, technical specialists like developers are valued primarily for their skills rather than educational background. Plus, developers’ skill levels vary wildly - even a 10-year developer from a top university’s CS program might have terrible programming skills, while a fresh high school graduate might be an incredibly skilled developer. That’s the nature of this field.

But there’s a reason many people still recommend going to university. Sure, “go to university to study more deeply” is one reason, but honestly they recommend it for more practical reasons.

To understand this reason, we need to think from the hiring manager’s perspective, not the applicant’s.

Why Mom Told You to Go to College

Living in South Korea, I’ve experienced plenty of obsession with Seoul-area universities, so I’m somewhat fed up with academic credentialism. But there’s a reason people can’t help saying education and majors matter: hiring managers can only obtain very limited information from just looking at your resume.

Information written on resumes is limited and hard to verify

Imagine we’re handling the hiring process for a new developer. By the way, small companies sometimes assign this work to practitioners, so regardless of your career level, you could be assigned this task anytime depending on the situation.

Now as hiring managers, we need to look through dozens or hundreds of applicant resumes per day and filter who will proceed to the second technical interview. The resume contains various information, but the applicant’s experience and technical skills are probably the core.

Anyway, what we want to know from looking at an applicant’s resume is “does this person meet the minimum skill level the company requires?” More coldly speaking, we’re considering whether it’s worth investing the interviewing team members’ resources to learn more about this applicant.

At this stage, it’s hard to know the person’s values or personality from just a few pieces of paper, so we generally focus on checking technical skills.

For senior applicants, we can roughly infer what path they’ve walked from their experience, but for juniors or new graduates who have almost no experience to speak of, we often can’t get much information about skills from their experience. (Of course, even among new graduates there are occasionally standout experts)

So what’s next to look at? The blog or GitHub attached to the resume - but what if even these are missing? What can we use to infer this person’s skills?

In this situation, we honestly have no choice but to look at school and major. Because there’s no more information available to judge the applicant’s skills. Sure, we could learn more detail through technical interviews later, but technical interviews themselves consume existing team members’ resources, so we can’t just conduct technical interviews with every single applicant.

That’s why people say educational background or major is still somewhat important. In other words, when you have nothing else, it’s minimum insurance.

Proving My Skills Is What Matters

Looking back at the situation we just examined, what matters to the company is “does this person have the minimum skills to work after joining?” - not the school or major itself. Whether high school graduate, Seoul university CS graduate, or bootcamp graduate, skilled developers get offers everywhere.

So if the following two people exist, which would a company choose?

1. Graduated from SKY CS program but no GitHub and can’t tell what projects they’ve done.
2. High school graduate but core contributor to a famous open source framework.

While this is a bit extreme, developer #2 would probably have higher selection probability. Because ultimately the company wants developers who work well, not simply someone who graduated from a good school’s CS program.

Naturally, compared to developer #1 who has no elements to verify skills besides education, developer #2 whose skills are somewhat verified through open source contributions represents less risk from the company’s perspective. However, if developer #2 had nothing to infer their skills from, then developer #1 would probably have higher selection probability.

In other words, if you can just prove your skills, you can overcome educational background or major - but identifying what skills the company wants is important. Some companies might want someone knowledgeable about a specific framework, while others might say frameworks can be learned on the job but solid foundational knowledge is necessary - desired technical specs vary by company and situation.

Ultimately, we just need to meet these specs regardless of major or educational background. But if just matching the company’s desired technical specs and skills means no hiring problems, do CS majors have no advantages over non-majors?

No, honestly that’s not true. Just because skills alone matter doesn’t mean non-majors are more advantageous.

Where CS Majors Have Advantages Over Non-Majors

CS majors have studied computers steadily for about four years through a specialized curriculum. Since they received education for four years, claiming no difference from non-majors would be a lie. But the difference between majors and non-majors isn’t programming skill itself.

These days, many bootcamp graduates brilliantly create applications using cutting-edge technologies in short periods. So what do companies expect from CS majors?

Know Your Enemy and Know Yourself

By the way, I’m not telling this story to say CS majors are more advantageous in these areas so just give up.

As I mentioned at the start, if you’re a non-CS major developer, you need to know what you lack compared to CS majors so you can supplement those areas. Only then can you set study direction and create your own strengths - so I want to first discuss the advantages I think CS majors have.

CS Programs Aren’t for Learning Coding

Honestly speaking, when both are new graduates, I think there’s not much difference in actual programming skill between majors and non-majors. Of course, this standard refers to developers who generally develop business applications at the application layer. Fields working at lower layers don’t have much room for non-majors anyway.

Many people misunderstand this point - thinking CS majors must be better at programming than non-majors. But what CS students learn at school isn’t functional programming or version control with Git or Flux patterns. CS students ultimately pursue understanding of computer system principles and structural thinking more fundamental than programming itself.

For example, in OS courses you learn about Process Scheduling. Process scheduling refers to theories and algorithms for how to efficiently execute multiple processes in a single processor system. You learn various algorithms like SJF, FCFS, RR - but unless you go pretty low-level, these concepts are rarely needed when making typical applications.

I learned these concepts at school so I know them, but never actually used them - though they did help a bit when understanding Node.js’s event loop.

That’s what CS programs are like. In other words, graduating from CS doesn’t directly translate to making good business applications. Making good business applications requires state management methods like MVC, MVVM, Flux, design patterns, appropriate development methodologies, and various other factors - schools don’t specifically teach these.

Some people hadn’t even heard of Git until they went to interviews. That’s why even CS majors sometimes re-enter schools or bootcamps after graduation.

If CS majors don’t have significantly better programming skills than non-majors, what advantages do majors actually have?

Higher Probability of Strong Foundational Knowledge

The answer is that a higher proportion have foundational knowledge about computers. When I say foundational knowledge, I mean knowledge forming the basis of computer-related technologies - data structures, algorithms, networking, mathematics, cryptography. Some say this knowledge is important, others say it isn’t, but I think these become more valuable as your career progresses.

Actually, these days there are so many good frameworks and most technologies are abstracted to be easy to use, so you can make programs without foundational knowledge. But cutting-edge trends change so fast - paradigms shift completely every 2-3 years - that developers who can quickly follow these emerging technologies inevitably have better market competitiveness.

These new technologies might look completely innovative and novel at first glance, but most evolved based on existing concepts. Which means ultimately the underlying technologies don’t change much.

For example, HTTP/2 replacing HTTP/1.1 might seem like something completely new because many features were added, but ultimately it’s just the existing HTTP protocol using TCP connections more efficiently. The foundational technology keyword here would be TCP.

Docker too - existing VM virtualization was too heavy, so instead of layering separate Guest OS for each virtual machine, let’s pull out just the parts needed to run applications into a common shared layer and separate only the process layer above that. The foundational technology keywords here would be virtualization and layer concepts.

The difference between traditional virtualization and Docker is ultimately how you stack these layers

In other words, even technologies that seem like completely new paradigms have existing foundational technologies underneath. So people with some knowledge of these foundations can have relatively smoother learning curves when new technologies emerge compared to those without foundational knowledge.

However, without this foundational knowledge, you have no choice but to study just that framework’s usage when new technologies emerge, or learn through information other developers already organized. This learning method is closer to memorization than understanding, so when similar technology releases a few months later, you have to repeat the same loop.

In other words, CS graduates learned most of this foundational knowledge at school regardless of how they spent those four years, and generally have higher probability of showing high adaptability to new technologies using this foundational knowledge. For these reasons, many developers expect this adaptability and potential from new or junior graduates of CS programs.

Build and Showcase My Skills

Compared to CS majors who spent four years grinding at school and learned foundational knowledge by force whether they liked it or not, non-majors often learned programming for only short periods through schools or bootcamps, so they inevitably have relatively less foundational knowledge than majors.

This is an unavoidable result from the nature of schools as educational institutions that must turn students into programming-capable talent in short periods. Most schools have 6-9 month learning periods - making someone employable by teaching computer fundamentals in such short time is nearly impossible.

Of course, listening to some bootcamp graduates, they work through chilling schedules of 8am to 10pm projects throughout that short period despite the brevity. (Everyone’s passion is impressive)

But compared to CS majors, there’s inevitably a difference in absolute study time, and schools teach coding or specific framework usage, not computer fundamentals, so as years accumulate, I often see people feeling burdened by learning new knowledge due to this lack of fundamentals and getting pushed back in competition.

However, looking at the many employed non-CS major developers, it’s clearly also true that non-CS developers have market competitiveness.

As mentioned above, developer jobs ultimately favor pure skill, so “how well I can showcase my skills” is the important point. Since my resume says multimedia engineering, when I interview I showcase my unique advantages even though I didn’t major in CS.

Blogs and GitHub Matter

Blogs are extremely helpful information from the hiring manager’s perspective. They’re a window where you can see at a glance this person’s thoughts, technologies of interest, study methods, problem-solving experiences, etc. in refined form.

Non-CS major developers have relatively less data on resumes that can verify their skills to hiring managers compared to CS majors, so actively using such means to showcase your skills and programming interest is good.

Also, many companies think positively about the act of sharing your knowledge with others, so steadily writing blogs definitely helps. If you have no clue what to write, start by translating foreign posts you enjoyed reading. In my case, I write about two main topics - one is just recording my thoughts like this current post, the other is technical posts.

Especially when writing technical posts, you’re forced to do tremendous research just from fear of spreading wrong knowledge, and organizing that research into writing refines it once more, so it actually helps studying more than just reading and tends to last longer in memory.

Also, the act of organizing and writing your thoughts itself helps tremendously with improving logical thinking. When speaking, people tolerate somewhat mismatched logic, but when writing, if logic and topics start blurring, the text just looks extremely awkward. I think you all know how important logical thinking is for developers.

And GitHub is so important I don’t need to say it twice. But empty accounts without steady commit history have little impact, so I recommend steadily committing whether doing side projects or contributing to open source. Honestly, when looking at someone’s GitHub account, if it’s full of dark green grass, you can’t help exclaiming “wow that’s amazing.”

My GitHub contributions. Not intense but at least shows "this person is doing something"

Plus, looking at GitHub repositories or what projects they starred shows what technologies they’re recently interested in. But the biggest advantage is you can directly see the code this person wrote. Beginners might feel embarrassed about opening their code to public spaces, but people don’t analyze and grade your code that closely, so just upload even small projects as Public on GitHub.

Looking at GitHub repositories roughly shows what technologies someone's interested in

Recently even bootcamps like Code States recommend students create blogs or GitHub accounts, so they seem to be teaching students that these things help employment.

Secure Your Own Expertise

Developers solve various real-world problems through computers. We mustn’t forget that these real-world problems aren’t single-category problems but extremely diverse categories. Software is used in various fields - medicine, finance, arts - and developers make that software too.

Solving these various field problems inevitably requires not just computer knowledge but knowledge from other fields too. You can’t make good programs without knowing what your program does, right?

Non-CS major developers often have their own original specialized fields, so using this well could become your own special weapon. Since working as a developer means having some expertise in development, people who had original specialized fields have at least 2 or more specialized areas.

For example, making accounting management programs like Douzone requires developers to have some accounting knowledge, and making audio editing programs like Logic Pro X requires developers to have knowledge about audio and music. But people who studied only CS for four years can’t easily acquire other field knowledge unless they specifically seek it out and study, so people who studied other majors before becoming developers have strength here.

Without audio and music knowledge, you can't make programs like Logic Pro X

In my case, I used to work as a sound engineer at an entertainment agency, so I have knowledge about audio and recording. Also, since I received steady music education from childhood, I have some music knowledge.

So I could understand the unfamiliar Web Audio API quite quickly, and could create desired instrument sounds by adjusting the oscillator properties this API provides. This music and audio theory knowledge is a specialized field just like CS, so it’s not something you can acquire short-term through cramming.

Many non-CS major developers think they’re lacking developers because they have less CS knowledge than majors, but thinking slightly differently, while CS knowledge might be lacking, they could be viewed as even more special ability holders possessing other field expertise.

Of course, if your current company work is completely different from your major it won’t help much, but I think maybe you could target niche markets using your major.

But Computer Fundamentals Still Matter

However, whether major or non-major, developers are still developers, and developers’ basic abilities start from understanding computers, so we can’t ignore this.

As I mentioned above, where CS majors have advantages over non-majors is exactly this foundational knowledge about computers. But since this foundational knowledge doesn’t immediately help employment, schools don’t teach it with much weight, and since theory is heavy, it’s too boring to self-study.

However, I personally think you should study at least these three regardless: data structures, algorithms, networking. These three subjects help a lot in practice knowingly or unknowingly.

Data Structures

For example, imagine a situation where you need to receive product information from the server and store it on the client. Each product has an ID value expressed as an integer.

{
  "goods": [
    {
      "id": 1,
      "name": "MacBook Pro"
    },
    {
      "id": 22,
      "name": "Jeans"
    },
    {
      "id": 100,
      "name": "Dried Squid"
    }
  ]
}

Imagine the server response comes down like this. Now we need to choose how to process and store this data. I roughly thought of about three methods:

1. Just keep it as-is in the array and use it.
2. Use the product ID as index and put it in a new array.
3. Use a map.

What advantages and disadvantages does each method have? Method 1 uses the response structure as-is from the server so no additional iteration is needed. But to access any specific product, you have to search the array every time, so $O(n)$ time complexity is required.

What about method 2? This method uses product ID as array index, so you might think value access can be done in $O(1)$, but not in JavaScript. In this case, array elements are Object types, so elements aren’t evaluated as the same data type like primitive types. Ultimately this array will be created as a list, and lists must search sequentially from Head to access specific elements, so access time is ultimately $O(n)$.

For details, see the Diving Deep into JavaScript Array Development and Performance post.

Plus, even if that array is a real array instead of a list, problems still exist. Product IDs are probably Primary Keys from the database, so as new products get added to the database, assigned ID values will keep increasing. So you can predict the memory-allocated array length will also keep growing. (Arrays are allocated contiguously in memory)

So in this case I’d probably use method 3. Since IDs are unique values distinguishing products, we can safely assume no duplicates. In other words, just throwing data into the map won’t cause collisions. Due to map characteristics, access itself can be solved in $O(1)$, and we just need to allocate memory for products received from the server, so it’s reasonable.

Without understanding arrays, you might make wrong choices

This example is quite simple but a situation frequently encountered in practice. Without basic knowledge about data structures - how arrays are allocated in memory, advantages/disadvantages of arrays vs maps, how values are accessed in these data structures - it would be hard to find the right answer among those three options for the current situation.

Algorithms

For algorithms, I’m absolutely not saying memorize how to solve problems like the Tower of Hanoi. Algorithms aren’t about memorizing how to solve some problem, but finding how to solve problems efficiently. It’s not important to solve the problem of finding the largest square in a given matrix - what’s important is pondering how to reduce even one for loop from the triple-nested for loop code I wrote.

At minimum, you should be able to calculate what time complexity your code has. What I just did above calculating the time complexity of accessing array elements vs list elements also falls within the algorithm domain.

Also, algorithms are an extremely wide and vast field, so you might not know where to start. In that case, I recommend starting with sorting and searching. Basic sorting algorithms like Bubble, Merge, Quick or search algorithms like binary search are quite intuitive so not that hard to understand.

Also, studying these algorithms naturally connects with data structures, so I recommend studying data structures and algorithms together. Solving problems on algorithm sites like Programmers is of course fun and good, but since these problems are closer to applied problems than fundamentals, I recommend establishing basic concepts first before attempting.

And these sites often provide features to see how others solved problems, but many people seem extremely focused on reducing code lines, so I don’t particularly recommend studying such code. I’m sure people who write ultra-condensed code on those sites don’t write like that in actual practice.

Networking

For networking, since you’re a web or app developer, you inevitably touch client-server communication features. Especially for web, it’s developed on top of networks, so network-related to the point you could say it’s developed on networks, so basic network knowledge is essential. Also, developing web applications produces various network-related problems that are hard to solve without basic network knowledge.

The representative network issue frontend developers probably encounter is CORS (Cross-Origin Resource Sharing) violations. This issue occurs when requesting resources from different origins like a.com requesting from b.com - the browser ignores the server response because of potential security violations.

The client sends a preflight preliminary request containing custom headers and methods to use before sending the actual request to the server - if the server doesn’t properly send down the right value using the Access-Control-Allow-Origin key in response headers after receiving this preliminary request, CORS violation occurs preventing communication.

CORS communication process

Without basic concepts about this communication process and security, you might use the widely available solution Access-Control-Allow-Origin: * in production and break server security. Plus, while frontend developers mainly encounter this problem, the backend actually needs to solve it, so without knowing what’s wrong, you might struggle alone and never solve it.

Wrapping Up

I wrote this post because of people who undervalue themselves for being non-CS major developers. Since I’ve never attended bootcamps or schools, I can’t empathize with everything, but hearing bootcamp or school graduate developers feel frustrated by major-related prejudice doesn’t feel good.

People who discriminate based on major are problematic, but also people themselves get trapped in that frame and say “is it because I’m not a CS major?” - I always tell them “developers are just developers.”

Actually, it’s somewhat natural that developers who studied 6 months at schools have less foundational computer knowledge than developers who studied 4 years at university. But I hope you don’t forget that developer evaluations aren’t based solely on computer knowledge.

And though I inevitably used the words “major” and “non-major” a lot due to the post topic, whether you’re a CS major or not is absolutely not important in development. Developers are just developers - there are just characteristics like developers specialized in computer theory vs developers who also mastered other field knowledge.

If someone tells you “CS major developers are indeed good” or “non-majors just don’t cut it,” that person’s mindset is wrong, not you. But as explained above, compared to people who studied CS for four years and graduated, people who didn’t have less foundational computer knowledge is true, so I think steadily studying fundamentals is good.

The IT market spectrum is extremely wide, and the developer specs required in each field are equally diverse. Which means regardless of major, if you combine your abilities well into your own weapon, you can have enough market competitiveness. If you study steadily and code enjoyably, work will naturally work out.

That’s all for this post on whether non-CS major developers are really at a disadvantage.