Our engineering principles

Our engineering principles

In today’s post, the Engineering team details the principles that guide their work.

At GetYourGuide, technical decisions are always made with a set of guidelines in mind: we created these Engineering Principles for precisely this purpose. These principles act as the foundation for how we work both individually and as a team.

We currently have 18 principles across seven groups: architecture, code, data, operations, problem-solving, technologies, and testing & quality assurance. These are reviewed regularly.

Architecture

Build resilient systems

Build systems that adapt to change and continue working when unknown challenges occur.

Build simple, single-purpose services

Small services have clear ownership, are easier to maintain, replace, and handover.

Use clear interfaces

The inside of our components are flexible and the interfaces we expose are uncomplicated. Invest time in getting them right — it pays off.

Code

Follow international standards

International communities are doing a good job setting standards. We follow these standards to avoid long internal discussions and to maintain a unified way of doing things. New systems should always follow international standards.

Write code for the reader

Code is read more often than it is written. We save time as an organization by writing code that is clear, straightforward, and easily understandable.

Leave code better than you found it

We continuously improve our code base by performing minor refactorings and polishing the pieces we work with. Finding something in a poor state isn’t an excuse for making it worse. We only change code when it is needed — and when we change it, it’s always for the better.

Data

Measure the impact of everything you do

If we don’t know how to measure the impact of something we shouldn’t start to work on it.

Use clear, accurate, and well-defined metrics

Spend time defining, aligning, and implementing metrics — it’s absolutely worth it. Confusing metrics definitions waste time.

Make data accessible

Our ability to innovate and improve is based on having access to accurate, well-formatted data. Our top priority when we’re designing systems is defining how to best expose data for analytics and innovative features.

Operations

Take complete ownership of our applications and services

You build it, you run it. The team developing a service is responsible for defining service level agreements (SLAs) and supporting the service in production. This ensures that a service or functionality is easy to debug and operate.

Know our systems’ health at any given time

We invest time and effort into monitoring our services and implementing health checks. We have excellent monitoring and alert systems in place.

Problem-solving

Learn fast and implement correctly

We cut corners to get a learning but we do not cut corners in the implementation that follows.

Tackle big problems through iteration

We don’t postpone or hesitate when it comes to solving larger problems if they hold high business value. We approach these problems in small steps and iterate to achieve change.

Technologies

Use the right tool for the job

We think about long-term benefits and bet on mature technologies. As for new technologies — we let them prove themselves in the industry first. We are fast-followers, not early-adopters.

Additional technology comes at an additional cost

We limit the amount of effort needed to support, update, and learn our tech stack. When choosing to implement something, take the full cost into account and aim to solve the problem with supported technologies first.

Leverage open-source as much as possible

We’re not here to reinvent the wheel. We leverage open-source technologies as much as possible.

Testing & quality assurance

Use gradual rollout and monitor each step

The true test of quality is to run things in production. By doing gradual rollouts and monitoring everything we ship, we can quickly form an understanding of how things work in the real world while limiting the blast radius of mistakes.

Write tests to save time and avoid repeating mistakes

We cover critical functionality with well-written tests. We add tests when we find bugs. This helps us avoid regressions.

Interested in putting these principles into practice? Check out the open positions on our Engineering team.
















Engineering Manager series part 4: productivity and how to boost team efficiency

Engineering Manager series part 4: productivity and how to boost team efficiency

Develop best practices at TA Society's first meetup

Develop best practices at TA Society's first meetup