The Telegraph Engineering culture in 6 core values:
- People come first
- We are all Accountable.
- We always optimise for iteration Speed
- We always think of Quality in mind
- We Automate where we can.
- We allow for innovation and experimentation.
People come first.
Our goal is to remove rules and aim for accountability, transparency and trust.
Writing software is a team sport. We strive to build an open and respectful work environment, learn from each other and provide continuous and honest feedback. We remain calm in stressful situations. We focus on great results rather than on process and exhibit bias-to-action and avoid analysis-paralysis. We seek to understand our strategy, market and customers.
We make time to help colleagues. We share information openly and proactively.
Focus on what people get done, not how many days they worked or time in the office. This creates our culture of creativity and self-discipline, freedom and responsibility.
We pair program. We invest in mentoring and continue to grow and retain knowledge. We maintain a healthy culture that rewards high-performers.
We support self-improvement through experience, observation, introspection, reading and discussion. As long as we all try and help each other grow and are very honest with each other. Our people manage their own career growth.
We are all Accountable.
Our teams should follow the motto of “You Build It - You Run It - You Own It” and should adopt a DevOps culture of shared ownership and skills. Teams are empowered to make any changes to the applications they own but with this responsibility also comes an ownership of the operational aspects.
We embrace failure, learn from mistakes and remain humble. We run blameless postmortems as screw-ups are expected to happen. In fact, if they don’t, it means we are not taking enough risks and moving too slowly. We can’t afford that. Nobody will blame you for screwing up. It’s actually almost the opposite: a well-written post mortem with good action points will get you praise. And the whole organisation will learn and improve and not make the same mistake again.
We always optimise for iteration Speed.
Our ability to iterate at speed is what will define our organisation in the market, will influence decisions the business makes and change how we view releasing new features and products.
Continuous Delivery will gives us faster build times and Continuous Integration testing will enable us to fail fast. We also avoid organisational bottlenecks by empowering the teams to make decisions, defining clear channels for quick feedback and breaking down teams into small units.
We always think of Quality in mind.
Quality of our products is paramount if we are to retain customers, given that we are an established brand our applications need to “just work” or fail gracefully to the end user.
Higher code quality reduces cost of maintainability and allows you to iterate faster. We invest in Software Craftsmanship and take TDD, Code reviews and good software engineering practices and standards seriously. We clean up redundant code when we can. We refactor code to in-house languages and never forget Technical Debt we need to pay back and transition our focus from building the right thing to building the thing right.
In order to develop new features and maintain code at scale we follow a consistent way of engineering practices.
We Automate where we can.
Automation is extremely high-leverage. We invest in automated testing, automated code quality checks, automatic handling of failures and automatically scaling up services at peak times. “Optimize for minimal operational burden” - Mike Krieger, instagram
We allow for Innovation and experimentation.
Be Lean. Focus on value first. Make it safe to explore and align people to the customer. Use a “Spike & Stabilise” pattern where we deliver business value using the smallest increment, measure the effects and decided to pivot or preserve. Then immediately pay down any tech debt if we’re on the right course.
We re-conceptualise issues to discover practical solutions to hard problems. We challenge prevailing assumptions and suggest better approaches.
Run Guilds, Hack days, document design discussions in the Blog, encourage tech talks. Contribute back to Open Source.