DevOPs

DevOps is a cultural and professional movement, not a predefined methodology, born from the practical experiences of its practitioners. It's unique to each organization but shares common principles.

DevOps is practiced by everyone in high-velocity organizations, not just a dedicated team. It fosters collaboration among well-connected specialists.

Key Principles:
- Prioritize safety, containment, knowledge access, and freedom for both employees and customers.
- Value people over products and companies.
- Embrace lean principles (eliminating waste, pull over push, continuous improvement, small batches, experimentation).
- Accept failure as normal and focus on rapid recovery.
- Automate workflows ubiquitously.
- Foster diversity within the organization.

Getting Started:
- Declare your purpose: Publicly state your goals, including the people you serve, the product, and the desired change.
- Define your beliefs: Outline how specific behaviors lead to positive outcomes, incorporating industry-specific aspects.
- Build empowered teams: Give teams the authority and context to make decisions, supported by leaders who share the team's purpose and beliefs.
- Form diverse bonds: Network across departments to build consensus and gather feedback.
- Develop products with strong value propositions: Focus on solving problems and creating things people love, not just things they want.
- Build a roadmap: Start with a vision, incorporate customer feedback and innovation, and group features into themes with clear outcomes. Expect features to change, but themes to remain relatively stable.
- Include "delighters": Add unexpected features that enhance user experience.
- Build iteratively: Develop features in small, testable increments with frequent customer feedback.
- Manage risk through small batches: Reduce long-term risk by embracing near-term volatility and frequent validation.
- Don't worry about scale (initially): Focus on execution and addressing theoretical concerns later.
- Regularly demo progress: Showcase work weekly to stakeholders to build transparency and address potential concerns.
- Choose appropriate tools and languages: Employ polyglot programming, selecting the best fit for each task.
- Utilize source code control, bug tracking, and continuous integration: Maintain short-lived branches with frequent merges to the mainline.
- Follow the "rule of four eyes": Ensure multiple people review important changes.
- Write tests incrementally: Don't plan massive upfront testing; write tests continuously alongside development.
- Practice continuous delivery: Always be ready to ship.
- Establish a single path for change: Maintain consistency in the process of moving code to production.
- Focus on availability: Minimize mean time to diagnose and repair failures.
- Collect meaningful metrics: Use high-resolution data with minimal systems.
- Plan for capacity: Graph key metrics, set limits, and anticipate future needs; auto-scaling is a reaction to failure, not a preventative measure.
- Alert only on actionable issues: Avoid excessive alerts that distract teams.
- Practice incident response: Use the OODA loop (Observe, Orient, Decide, Act) and conduct postmortems after unexpected incidents.
- Apply principles of scalable systems design: Treat systems as autonomous actors with clear promises and boundaries.
- Embrace humility: Recognize that others possess greater expertise in various areas.
- Focus on simplicity, extensibility, and reuse: Prioritize user simplicity, even if implementation is complex.
- Implement DevOps in a business context: Select a project, gather stakeholders, and apply the DevOps principles iteratively over an 8-week period, demonstrating progress weekly.

DevOps is a practice, not just a buzzword: It's about consistent application of principles and behaviors, adapted to individual contexts.