Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
Delivering architecture specifications isn't a one-time task. Architects should engage with the workload team throughout implementation. This article outlines practical steps for architects during implementation, including continuous collaboration tasks, proof-of-concept (POC) usage, and technical debt management to help you succeed.
Continuous collaboration tasks
Provide clarity. Be available to clarify specifications so implementation teams stay unblocked. Participate in iteration planning and team meetings to address potential blockers.
Advise on implementation sequencing. The transition from design to production is inherently iterative, with change expected throughout. Reflect this reality in your sequencing decisions by prioritizing high‑risk components and critical path items early, allowing teams to identify feasibility issues and apply lessons learned across the workload.
Set implementation review checkpoints. Ensure that workload teams establish regular checkpoints to compare the implementation with the architectural specification. This practice helps ensure that the team implements your design according to your specifications and that the specification meets the predicted requirements. A working feedback loop can mitigate against design or implementation errors.
Communicate with stakeholders. Architects use their established relationship with stakeholders and understanding of the workload to relay implementation team concerns or negotiate requirement changes.
Make environment recommendations. Workload design often extends beyond designing for production and its disaster recovery. Architects can also assist workload teams in right-sizing preproduction environments.
Use a proof of concept (POC)
Architects use POCs in their designs to inform decisions about the design specifications for the workload architecture. These POCs can also provide insight into the feasibility of the actual workload implementation.
Risk: Never consider POC code as production-ready. POCs are often built without security, logging, or error handling to prove a specific concept quickly. Be explicit that POC code is disposable and should not be copy-pasted into the production codebase. Instead, use the POC to learn, then write the production code using established engineering standards.
Manage technical debt
Sometimes, to meet a deadline or other constraints, a team might incur technical debt. The architect's role is to ensure the debt is:
- Intentional: The debt is taken on deliberately, not accidentally. Being intentional helps ensure short-term agility without compromising long-term viability.
- Documented: Track the debt in the backlog. Documented technical debt quantifies risk and cost, giving you an auditable backlog. Use the backlog to align remediation with roadmap milestones, budget cycles, and platform guardrails.
- Repayable: Use the learnings gathered when you take on technical debt to create a thorough, cost-effective plan to address it in future iterations.
Collaboration with platform teams
Some organizations split responsibilities between workload and platform teams, as seen in Azure landing zones. For workloads that partner with platform teams to co-deliver solutions and value, it's important to collaborate with those teams.
Advocate for golden paths—secure and automated ways to consume platform resources. If you don't collaborate with platform teams, your design might miss the cost advantages of available platform-provided offerings, or you might design a solution that violates platform-mandated constraints on workloads.
Mentorship and knowledge sharing
Set the tone. Explain decisions early and often through reviews and lunch-and-learn sessions to empower the implementation team to make decisions that align with the overall vision.