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.
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.
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.
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.
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.
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.
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.