Whenever someone asks you what you do for a living, do you respond that you are an engineer or a developer? Do you know why you choose one term over the other? More importantly, do you think it even matters?

Since my college graduation in 2016 and my subsequent dive into software engineering, I've witnessed the heated debate in the tech community about these terms. The common refrain is, "Software engineers and software developers are the same thing." While many believe this, I contend that we shouldn't let this notion go unchallenged.

I firmly believe we need a clear distinction between these two roles. Non-tech workers might use "developer" and "engineer" interchangeably, but when those within the tech industry do the same, the implications are significant. Using these titles carelessly not only risks diluting our professional identities and undermining our negotiating power in job markets but can also lead to misconceptions about our responsibilities. This might result in us either underplaying our roles or being pushed beyond our scope of expertise. To address this, I've crafted a framework that relates roles like "developer", "engineer", "coder", and "programmer" to the stages of the Software Development Life Cycle (SDLC). This approach helps define the scope of our responsibilities more clearly and ensures we communicate our expertise effectively.

The skills and responsibilities of the roles are encapsulated by the position above it.

The Nomenclature

Before we can standardize these concepts, it’s crucial to understand the definitions of these terms and how they correlate with the roles they represent. Note that here, the level of skill takes a backseat to the scope of responsibilities.

Software Development Life Cycle (SDLC)

According to Synopsis.com, "The Software Development Life Cycle (SDLC) is a structured process that enables the production of high-quality, low-cost software, in the shortest possible production time. The goal of the SDLC is to produce superior software that meets and exceeds all customer expectations and demands."

The Software Development Life Cycle

Scope

The term "scope" is often used in different ways. For the sake of this article, "scope" refers to the boundary of responsibilities based on the role. For example, a Coder's scope is much smaller than that of an Engineer.

Roles

Coder

“A person who writes code for computer programs.”

In today’s job market, the term “coder” often refers less to a professional title and more to individuals who code, possibly without it being their primary occupation. They might be professionals in fields outside of tech or software development who utilize coding to augment their primary work. Consider, for example, a mathematician who employs MATLAB and Python for statistical modeling, or an accountant who leverages SQL queries for automation.

These individuals write code typically intended for their use, focusing on practical results rather than broader applications. The code’s quality, in terms of industry standards, might not be their priority, provided it accomplishes the task efficiently. Therefore, their scope of responsibility, in the context of software development, is narrower, as their coding is a tool rather than an end in itself.

Programmer

“A person who writes computer programs.”

While demand for traditional programming roles might not be as robust as it once was, owing to the rise of automation and off-the-shelf software solutions, these skills are still highly valued, especially in companies leveraging technology to solve specific problems without a dedicated tech department.

The key distinction between a programmer and a coder lies in the scope of their work. While a coder focuses on writing code to accomplish individual tasks, a programmer crafts entire programs designed for multiple purposes, reusability, and accessibility by non-technical users. Although the fundamental skills are similar, a programmer typically possesses a deeper understanding of their chosen language and principles of software design, primarily because their code is intended for broader use. This wider user base necessitates rigorous testing to ensure functionality and user-friendliness, anchoring a programmer's role in a deeper developmental context compared to a coder.

Developer

Given the ambiguity surrounding the term "developer," it's prudent to craft a definition specific to the industry of technology. Starting with the root, "develop," we understand it as to grow, advance, or elaborate; and to bring into existence or use. Thus, in the context of software and technology, a developer can be defined as:

"someone who uses programming skills to create or enhance sophisticated software systems."

This role sees a notable increase in both the scope and complexity of tasks. Developers are not just writing code; they're involved in the conceptualization, creation, and sometimes the deployment of software, requiring domain knowledge, comprehensive system design, rigorous testing, and an understanding of distribution to end users. While they may not oversee all stages of the Software Development Life Cycle (SDLC), their role extends into the design and deployment phases, often contributing insights and adaptations. This responsibility typically builds on the foundation laid by engineers or project managers, yet requires a developer's active awareness and participation. Interestingly, a pattern emerges here: each subsequent level encapsulates the skills and responsibilities of the previous one, a trend that continues as we explore the role of engineers.

Engineer

"a person who designs, builds, or maintains engines, machines, or public works."

An engineer's purview spans the entirety of the Software Development Life Cycle (SDLC). They inherit all the skills and responsibilities of the roles we've discussed earlier, and then some. From the inception and requirements stages of the SDLC, engineers play a pivotal role. They shoulder the significant responsibility of designing applications or systems to meet specific requirements and oversee the deployment and subsequent maintenance of the software.

While an engineer's vast scope may imply a trade-off between breadth and depth, this isn't necessarily the case. An engineer might have extensive knowledge across multiple domains without sacrificing depth in particular areas. Their holistic understanding and experience position them uniquely to shepherd a project from a nascent idea to a tangible, functioning product. This distinction is paramount: while coders, programmers, and developers excel in their domains—completing tasks, automating processes, or crafting software—it's engineers who envision and build transformative solutions, catalyzing innovation and advancing the technological frontier.

The scope of responsibilities for each role.

Why Does This Matter?

Understanding the precise scope of our professional roles is crucial. Consider an engineer tasked only with script automation or a programmer suddenly thrust into managing a large, multifaceted project. Both scenarios are suboptimal and, unfortunately, not uncommon. Recruitment processes frequently misalign job responsibilities with titles, leaving new hires either underwhelmed or overwhelmed. This disconnect isn't just frustrating—it's a running joke in the tech community, with job listings often mismatched with the actual skills and experience required.

However, it's not enough to lampoon recruiters or employers for these discrepancies. We, as tech professionals, must take ownership of our titles and the competencies they represent. If we don't clearly define our roles, we can hardly blame others for misunderstanding them. The terminology we use matters profoundly. By adopting a structured approach to our professional nomenclature, we can tackle this inconsistency, forging a clearer path in our careers and arming ourselves with greater leverage in the job market.

Conclusion

By now, I hope you see the profound importance of accurately defining your role in the tech industry. Yet, this is just the tip of the iceberg; the conversation expands further into tech subdomains like infrastructure, data science, and cybersecurity. The boundaries between the roles of coder, programmer, developer, and engineer are not rigid. Career trajectories are fluid — a coder can evolve into an engineer, or an engineer might choose to step back into a programmer or coder role, perhaps to pivot to different industries or to prioritize other aspects of life.

Clear definitions are more than semantics; they're tools for empowerment. They enable us to align our career paths with our skills and aspirations more accurately, avoid job mismatches, and articulate our career goals with clarity and confidence. So, as you ponder the distinctions and where you fit in, I leave you with the question we started with: Are you an engineer, or a developer?