Product Engineering in detail | Our Process in a nutshell | Back to Overview

Software Engineering

We regard software development as a craft. In this sense we must always be caring for the tools we use. For software development this requires constant evolution since the industry is built on a stream of constant innovation. This is not only true for the ways we build and think about interfaces to enable interaction with computer systems, but also for the architecture of entire systems.

While it used to be sufficient to put together some HTML as a frontend 25 years ago, today we expect fluidity and ubiquitous interfacing. These we accomplish by employing technologies like kibana, react and react native in combination with redux, meteor, angular2 or ionic2 - to just mention a few.

In order to be able to evolve and exchange user facing frontends over time and across verticals, we use a service oriented architecture as a model to guide our thinking when building backends. On a technical level we create these backends using frameworks like tensorflow, express, symfony2, node, blockchain along with languages and tools like golang, redis, elasticsearch, rabbitMq, and more. This collection of more or less meaningless buzzwords to a non-coder-ear are meant to bring the point across that we do not believe in specific technologies, frameworks or languages, but in using the best tool for solving what needs to be solved. Having said that, we believe that proper architectural patterns serve as a strong foundation for creating software that can evolve over time along vectors like market demand or changing request rates.

One of the strongest patterns we work with is worth some more description - Microservices:

In traditional software development we used to build a single, monolithic application that contains all of the required functionality. Since it does not add value to recreate the same basic functionality for each application, frameworks were developed that took over the core functions and provided them to the business logic. Most frameworks provide some form of modular extension mechanism that allows developers to create reusable units. While this helps a lot if the entire software is written in one language, one framework and one piece, the reusability of modules is limited by a number of factors which include critical aspects like scalabilty, adaptability and maintainability. The solution to creating a modular structure without a strong binding between the components that creates a negative effect, is called microservice architecture. This architecture takes advantage of developments that happened in the recent years.

By designing individual and stateless services that are addressable

• using standard HTTP methods for communication and 

• low bandwidth data formats like JSON 

• along with JWT for authentication and authorization handling,

it has become possible to not only add new components easily, make software easier to 

• scale,

• maintain

• and extend

than traditional approaches while also making the application as a whole more robust. If one service fails, it does not compromise the entire application. This architecture is what allows Amazon, Netflix and others to rapidly develop and test new features. The following feature outlines the basic concept showing a number of applications being used by individuals while each of the applications uses and reuses the appropriate services for its purposes. Each service in turn utilizes resources like third party services, database systems, file storage systems to fulfill its purpose.

Typical services that can be reused across a wide range of applications are:

• authentication

• user-account management

• file storage

• media manipulation

• notifications (mobile push/email/etc)

• etc...

Call us today and tell us about your project! We are happy to schedule an initial meeting to figure out where you stand and how we can contribute.