We are accountable for the entire lifecycle of the products, features, and systems we build or inherit; from design, development, test, deployment, impact, maintenance, and even deletion.
We continually monitor and support the systems we own and are empowered to maintain and improve them.
We share knowledge around the systems we own to ensure continuity and empower effective support.
We put in place logging and metrics to monitor the health and performance of our systems and help with triaging and debugging of issues.
We ensure good coverage on logging and alerting so that problems can be identified rapidly.
We step in to support the response to incidents involving our systems and ensure we document comprehensively to aid others.
We value speed of iteration and delivering value to users (internal or external) faster and more frequently, but without compromising quality.
We slice our work thin, allowing us to commit code within hours.
We use DevOps practices to confidently push changes multiple times a day.
We avoid “Big Bang” releases, favouring small releases that can easily be rolled back if needed.
We refine tasks to their simplest form to promote agility and support rapid iteration.
We use feature toggles to allow us to confidently push changes, enabling internal testing and phased rollouts.
We maintain the cleanliness of our deployment pipelines, ensuring streamlined processes and optimal performance.
We work to master our craft to benefit ourselves, our teams, and our customers.
We believe that no process, code, product, skill, individual, or Engineering Principle is ever ‘100% complete’.
We accept that failure can happen, but we look to fail forward, embracing all experiences, good or bad; always focusing on what learnings we can take to help us improve, sharing those learnings wherever possible.
We believe that everything can be improved through iteration.
We monitor and understand our career progression and routinely share our learning experiences with others.
We use retrospectives and post-mortems to learn from experience and thus drive improvement.
We engage diligently in Code Review, using it as an opportunity to share useful feedback and help others learn and improve.
We ensure room for learning time in our weekly schedule, catering for all learning styles.
We pass on our skills, knowledge, and experience to our teams to level them up and avoid getting stuck later.
The data we hold are our biggest assets. We handle them sensitively and treat them with respect.
We protect our data and care about data integrity.
Our editorial content, records data, customer data and behavioural data represent years of investment and research by us and our users.
Our data drives the business and should be handled with care.
We use tools for version control and migrations to ensure data integrity and minimize risk in database changes.
We automate all changes to the database schema and provide rollback automation.
We prioritize clarity, efficiency, scalability, and normalization in schema design.
We backup data and test restore regularly.
We use the principle of least privilege when accessing data.
We exclude Personal Identifiable Information (PII) from our development databases and never log PII.
We write code to defend our databases against common exploits, such as SQL injections.
We comply with data regulations, such as GDPR, and automate these processes.
We work to minimize obstacles that can impact any team’s ability to achieve their goals.
We, as teams, have the capability, flexibility, and can-do attitude to tackle any work needed to progress.
We, as teams, build platforms and codebases that are accessible to all.
Communication is vital; as teams we always have awareness of changes, and priority is given to unblocking any work on our systems.
We document our code/services to ensure they are accessible to others.
We communicate our plans/intentions to the owning team before we go ahead and make changes to their code/services.
We show willingness to support others when they are having difficulty working in our codebases.
We share the load of common maintenance work and improvements between teams.
We work with teams across the business to achieve goals through engineering solutions.
We provide technical context to the business that aids prioritisation and planning.
We work with other engineers looking to contribute or use our systems, for example, providing documentation, pairing on implementations, or accepting pull requests.
We always leave code better than we found it; every little improvement helps, and the effort will be appreciated by others.
We collaborate with product to prioritise technical work and to ensure we have time to develop high quality solutions.
We write tested, maintainable, and documented code that is accessible to those reading it for the first time.
We prioritise pair programming and ensure that all code is reviewed.
We embody our learn and improve principle by making improvements to our code as we learn.
We develop high quality solutions and push back on deadlines that force cutting corners.
We ensure good coverage on testing.
We leverage automated tests to gain confidence in deploying to production.
We rigorously test any changes that may affect the data.
We take care to balance technical improvements with other work, finding time to improve performance, fix bugs, and build out our systems to a high standard.