You might have noticed from our website, other blog posts as well as from our interview questions that we are expressing who we are, what we do and who we are looking for in terms of software “engineering”, not software “development”. It stands to reason that you might ask yourself what the difference is, so we will try to present our take on it in this blog post.

First off

There isn’t a set of criteria set in stone that you can use to put someone in one bin or the other. Also, opinions and finer points differ depending who you ask.

However, there seems to be an overarching consensus that the difference between software engineers and software developers might be compared to the difference between civil engineers and builders. They’re both important, but fulfill different roles when taking on a project.

Having that in mind, we think that a software engineering role comes with an overarching, end-to-end responsibility of something: maybe a feature, maybe a module, maybe an app, maybe a whole project. Regardless of the scale of the problem, the software engineer will be responsible for designing a solution (most likely using a set of best practices and principles, his or her experience as well as some design process). While doing so, the software engineer will consider potential tradeoffs, explore extension points as well as have a holistic view that includes not only the solution to the problem but also aspects such as scalability, security, extensibility, maintainabilitye etc. For some projects the work will also include validating the design, using various approaches. Documentation may also be an expected output.

On the other hand, the software developer will be responsible for implementing the solution. He or she will be the one working with the bare metal, most likely combining an arsenal of tools and technologies, hitting and solving technical (platform) issues and testing the end result. During this part of the work, the developer may well involve the engineer to validate the design, raise design issues or point out parts that have to be partly or completely redesigned. In a way, the developer is working off the engineering blueprints while also providing valuable feedback for them.

It’s important to note that the software engineering and software development roles may be played by the same person. Also, the responsibilities of the two may well overlap, there isn’t a line in the sand where one ends and the other one begins. However, the conceptual difference between the two should now be clear(er).

With that in mind

We could also come up with a list of sorts that bullet-points the above. It’s imperfect and far from universal, but it might still help.

Software Engineers:

• are involved in coding + requirements gatherings + design decisions + testing + maintenance + software architecture

• put an emphasis on engineering principles + reliability + scalability

• might also be involved in leadership positions

• use customer feedback to make improvements

• create and maintain documentation

• have a big-picture role within the team

• work with the end clients, software developers, non-technical stakeholders

• is expected (but not mandated) to have a CS education/background

Software Developers:

• code parts of the software development process

• write code that meets specific requirements

• might be also a person with a different academic background than CS

• solve specific problems

• work with software engineers and QA specialists

Where does this leave us

We at InfiniSwiss are a relatively small team. Most of our work falls under the umbrella of software services, specifically team augmentation: this means that we are part of the client’s technical team and work alongside them. Our differentiator is that we cover the sweet spot between a software development agency and contractors, therefore the customer’s expectation of us is that we fill a role that’s more geared towards what we discussed above as “software engineering” than development.

Specifically, this means that the customer doesn’t hand us a spec and we hand back the implemented product, but rather the customer approaches us with a problem and asks us for a solution. This is why each and every one of us have to play the software engineer role and come up with (design) a solution. More often than not we are also the software developers implementing it, but the point is the customer relies on us to engineer the product.

This approach is also reflected in our interview questions, most of which are not “googlable” (i.e. they are not “api questions”) and touch more on patterns, principles and how things work behind the scenes. This translates in our daily work because when the customer asks a question like “how can we speed up the retrieval of data when we have 500m records” or “how can we make this UI fully customizable” most likely google won’t help off the bat, while solid engineering knowledge and experience will.

In the years since InfiniSwiss has written its first line of clean code, we have always tried to educate and position ourselves on the side of engineering, while also being adept at development. We are and want to be seen as pragmatic, problem-solving software engineers.

If you feel this resonates with you and want want to be part of a team that:

• makes no compromise when it comes to high standards;

• writes high quality clean code;

• has a continuous learning mindset;

• takes all kinds of feedback seriously;

• allows you to have a voice and make a difference;

• is there to share knowledge…

…then you are reading the right blog post for your future development.

Drop us a line @ [email protected] and let’s talk! We can’t wait to meet you!

Written by:

Monica Ratiu

[email protected]

HR guru, people connector, admin wizard - keeping the gears turning

Follow: