Architecture strategies for formalizing development practices

Applies to this Azure Well-Architected Framework Operational Excellence checklist recommendation:

Software development involves more than producing code. Developers need to clearly understand what to build and why. Product owners and managers maintain visibility into what work is being done and how it's progressing. By establishing consistent practices, teams can deliver quality software, surface risks early and manage expectations, and track progress.

This guide provides recommendations on how to run software development in a structured, predictable, and collaborative manner.

Establish standards for managing change

In software development, every unit of work is a change. Even new features represent a shift from a nonexistent state to an implemented one.

When initiating work for a requested change, keep these considerations in mind:

• Collaborate. Teams should work together rather than in isolation. Most changes affect more than one component or role. Involve developers, testers, operations, and product stakeholders early to ensure that important details aren't missed and that everyone understands the impact on their area. Working together also leads to more accurate effort estimates because people with relevant experience can contribute their perspective.

  Keep the goals of collaboration simple. Agree on the scope of a change, identify dependencies, and break the work into clear, manageable tasks and document them in a backlog.

• Communicate. Standardize how the team communicates releases, both internally and externally. Define what information should be shared with external audiences (such as customers), the appropriate level of detail, required onboarding or support documentation, and the communication timeline. For example, notify stakeholders two weeks before a release and send a reminder 24 hours before deployment.

• Retrospect. Regularly review each development cycle to identify what worked, what didn't, and what can be improved. Keep these reviews blameless and focused on learning.

  Use this opportunity to check whether standard practices are effective. For example, check whether developer tasks were clearly defined, time estimates were accurate, and processes are working as intended.

• Reports. Standardize reports on how the product is changing. Keep the reports focused on product growth rather than individual developer productivity. For example, it's a good idea for stakeholders to track:

  • Adoption growth
  • Performance improvements
  • Onboarding time
  • Incident frequency

Choose industry-proven tools

Instead of inventing your own processes, use proven processes like Agile, Scrum, and Kanban boards.

Using proven approaches saves time, reduces effort, and makes it easier for team members because most of them should already be familiar with these tools. Standard tools also simplify onboarding new hires and improve collaboration across teams.

Tradeoff: Agile methodology can become too rigid if it's overly prescriptive. Strive for a balance between well-defined standards and innovation.

Standardize how development work is recorded

Standardize a template for capturing discrete units of work. It should be written from the user's perspective and adhere to these principles:

• Independent. To avoid overlapping work, one story shouldn't depend on another.

• Negotiable. Work should be open to discussion and refinement because the work must be realistic from a development perspective and aligned to business goals.

• Valuable. Work must clearly benefit the user.

• Estimable. The team must be able to confidently estimate effort so that it's possible to deliver the feature on time. Prefer small items that can be completed in a few weeks or less.

• Testable. There must be a clear way to verify the functionality and deployment of the feature.

Also, standardize a template for acceptance criteria so the team and stakeholders know that the work is complete. Each unit of work should be an acceptance criteria that's not ambiguous and can be verified by tests.

Make sure everyone agrees on what "done" means for a development cycle. Requirements should include completed code, finished testing, updated documentation, and addressed accessibility. Clear definitions prevent unfinished work from accumulating.

AI opportunity: You can templatize writing work descriptions and acceptance criteria based on organizational policies. Use Copilot to generate initial drafts from the templates. AI can also enforce standards by validating documents against templates. For advanced scenarios, use AI agents that are grounded in your standard templates to consume outputs from code reviews and root-cause analyses, and then automatically create compliant work items for identified defects and improvements.

Standardize coding practices

Coding practices define the conventions and guidelines developers follow when writing and collaborating on code. These practices establish how code is structured, documented, and reviewed within and across teams. They also speed up developer onboarding and reduce defects caused by implementation variations.

• Development environment and tools. Standardize IDE configurations, development tools, and approved code generation tools across teams. Enforce the use of common libraries, frameworks, and package management standards to promote reuse, ensure consistency, and comply with organizational security requirements.

• Coding conventions. Define and document coding standards that cover naming conventions, code structure, and formatting. We recommend that you enforce standards in code blocks that handle exceptions and implement instrumentation. Clear conventions make code easier to read, understand, and maintain, and help teams work consistently across features and components. Make sure these guidelines can be accessed by all developers and are regularly updated as the codebase evolves. For example, you can use EditorConfig in Visual Studio to enforce coding styles.

• Code repository. Establish and enforce standardized branching strategies, like Gitflow, GitHub Flow, or trunk-based development, across all repositories to ensure consistent code integration and release practices.

• Peer reviews. Define pull request (PR) standards that specify acceptable PR size, required title and description formats, and mandatory review requirements. Require peer reviews for every code change to ensure that standards are followed. Define a collaboration model for PR reviews that sets expectations for responsibilities, feedback, and approvals.

• Templates for common artifacts. PR descriptions, commit messages, and unit tests are classic examples of artifacts that can be templatized. Make sure the documentation includes purpose, context, and testing steps.

• Test coverage. Require unit tests for all new code and significant modifications to existing code. Tests should follow agreed-upon patterns and include meaningful assertions to verify functionality.

AI opportunity: AI tools can automate repetitive, manual tasks in coding and review processes. GitHub Copilot can generate standardized code blocks, unit tests, and pull request descriptions, which reduces the effort spent on routine work.

Tools like SonarQube and Copilot Labs can automatically identify deviations from coding standards, missing test coverage, and common anti-patterns. Offloading these repetitive validation tasks to AI frees teams to focus on higher-value work. However, human review remains essential because development practices are critical to the correct implementation of business logic and overall workload quality.

Standardize integration practices

Integration refers to the automated processes and conventions used to validate, secure, and package code as it moves through the development life cycle. It includes how code changes are built, tested, scanned, and prepared for deployment as part of continuous integration pipelines.

Standardized integration practices are necessary to validate code against defined quality and security requirements and also enable faster feedback loops for developers.

• Build automation and integrated testing: Standardize automated builds that run on every code push and enforce automated unit and integration testing with defined coverage thresholds, where applicable.

• Code quality analysis: Apply static code analysis and quality gates by using approved tools to ensure that code meets defined quality standards before promotion.

• Dependency management: Continuously scan dependencies for outdated or vulnerable components and integrate security scanning, including Static Application Security Testing (SAST), Dynamic Application Security Testing (DAST), and secret detection.

• Artifact management: Standardize package and artifact versioning, storage, and retention policies to ensure traceability and reproducibility.

• Monitoring and reporting: Collect and monitor build and pipeline metrics to track quality, performance, and compliance.

AI opportunity: Consider using AI-driven workflows to automate repetitive integration tasks, like generating CI/CD pipeline configurations, creating test scaffolds, and detecting build or test issues, like missing tests or dependency problems. Although AI speeds up pipeline setup, retain human review to validate critical decisions.

Azure facilitation

Azure Boards is a web-based service that enables teams to plan, track, and discuss work across the entire development process. It's well suited for Agile-based development practices.

GitHub Projects is a customizable project management tool that can organize projects and integrates by using issues and pull requests in GitHub.

Related links

• Best practices for Agile project management
• Azure Boards

Community links

• GitHub Projects

Operational Excellence checklist

Refer to the complete set of recommendations.