Skip to main content
Established Values in Application Development

Established Values in Application Development

$251.00
How you learn:
Self-paced • Lifetime updates
Your guarantee:
30-day money-back guarantee — no questions asked
Toolkit Included:
Includes a practical, ready-to-use toolkit containing implementation templates, worksheets, checklists, and decision-support materials used to accelerate real-world application and reduce setup time.
When you get access:
Course access is prepared after purchase and delivered via email
Who trusts this:
Trusted by professionals in 160+ countries
Adding to cart… The item has been added

What does the Established Values in Application Development course cover?

Established Values in Application Development is covered here in 8 modules: Defining and Enforcing Architectural Principles, Sustainable Code Quality and Technical Debt Management, Secure by Design and Compliance Integration and 5 more. The outline lists 48 specific topics, opening with select whether to adopt domain-driven design (DDD) or layered architecture based on system complexity and team familiarity, weighing long-term maintainability against onboarding.

How do you approach Established Values in Application Development step by step?

The work is sequenced in 8 stages. It starts with Defining and Enforcing Architectural Principles, moves through Sustainable Code Quality and Technical Debt Management and Secure by Design and Compliance Integration, and ends at Evolution and Deprecation of Legacy Systems. Each stage carries its own topic list, so the sequence is followed rather than summarised.

What is in Module 1 of the Established Values in Application Development course?

Module 1 is Defining and Enforcing Architectural Principles. It works through select whether to adopt domain-driven design (DDD) or layered architecture based on system complexity and team familiarity, weighing long-term maintainability against onboarding overhead., decide on strict enforcement of architectural boundaries using compile-time checks, runtime validation, or documentation-only guidelines, considering CI/CD pipeline impact., implement a mechanism to audit architectural drift by integrating.

How is the Established Values in Application Development course delivered?

The Established Values in Application Development course is fully self-paced with immediate online access after enrolment. Access does not expire and future updates are included at no cost. It can be taken on any device, and a certificate of completion is issued by The Art of Service when you finish.

How much does the Established Values in Application Development course cost?

The Established Values in Application Development course is $247 as a one time payment. There is no subscription, no per seat licence and no hidden fee. Enrolment carries a 30 day satisfied or refunded guarantee, so it can be assessed in full before you commit.

More answers: what you get with every course, refund policy, all help answers.

This curriculum spans the breadth of a multi-workshop technical leadership program, addressing the same architectural, operational, and organizational challenges encountered when aligning engineering teams across a large-scale application modernization effort.

Module 1: Defining and Enforcing Architectural Principles

  • Select whether to adopt domain-driven design (DDD) or layered architecture based on system complexity and team familiarity, weighing long-term maintainability against onboarding overhead.
  • Decide on strict enforcement of architectural boundaries using compile-time checks, runtime validation, or documentation-only guidelines, considering CI/CD pipeline impact.
  • Implement a mechanism to audit architectural drift by integrating static analysis tools (e.g., SonarQube, ArchUnit) into pull request workflows.
  • Balance consistency across services with autonomy in microservices teams by defining minimum architectural compliance requirements per service.
  • Establish escalation paths for exceptions to architectural standards, requiring approval from a central architecture review board.
  • Document architectural decisions using ADRs (Architecture Decision Records) and integrate them into the team’s knowledge repository with version control.

Module 2: Sustainable Code Quality and Technical Debt Management

  • Set thresholds for code coverage in unit and integration tests, determining whether to block merges below specified levels or allow opt-outs with justification.
  • Introduce incremental technical debt tracking by tagging code smells and known issues in version control with metadata (e.g., TODOs with owner and deadline).
  • Allocate sprint capacity for refactoring by negotiating a fixed percentage (e.g., 15–20%) with product owners, balancing feature delivery and code health.
  • Configure linters and formatters to run automatically in developer environments and CI pipelines, standardizing code style across the team.
  • Conduct periodic code health assessments using metrics such as cyclomatic complexity, duplication, and dependency coupling to prioritize remediation.
  • Define ownership models for legacy components, assigning teams or individuals responsible for incremental modernization.

Module 3: Secure by Design and Compliance Integration

  • Embed security requirements into user stories by requiring threat modeling for high-risk features, using STRIDE or similar frameworks.
  • Integrate SAST and SCA tools (e.g., Checkmarx, Snyk) into CI pipelines, determining whether to fail builds on critical vulnerabilities or allow temporary waivers.
  • Select encryption strategies for data at rest and in transit, choosing between platform-managed keys and customer-managed keys based on compliance needs.
  • Implement role-based access control (RBAC) with attribute-based extensions, defining policies that align with organizational job functions.
  • Design audit logging to meet regulatory requirements (e.g., GDPR, HIPAA), ensuring logs capture who, what, when, and are immutable.
  • Coordinate with legal and compliance teams to map application controls to specific regulatory articles, maintaining an evidence trail for audits.

Module 4: Operational Resilience and Observability

  • Define service-level objectives (SLOs) for critical user journeys, setting error budgets that trigger operational reviews when exceeded.
  • Instrument applications with structured logging, metrics, and distributed tracing, selecting open standards (e.g., OpenTelemetry) for vendor portability.
  • Configure alerting thresholds to minimize false positives, using dynamic baselines and anomaly detection instead of static thresholds.
  • Implement circuit breakers and retry policies in service-to-service communication, tuning timeouts based on dependency SLAs.
  • Design graceful degradation paths for non-critical features during outages, ensuring core functionality remains available.
  • Run periodic failure injection tests (e.g., Chaos Engineering) in staging environments to validate recovery procedures.

Module 5: Dependency and Third-Party Risk Management

  • Establish a software bill of materials (SBOM) generation process for all production artifacts, using tools like Syft or CycloneDX.
  • Define approval workflows for introducing new third-party libraries, requiring security, license, and supportability reviews.
  • Monitor for end-of-life or unmaintained dependencies using automated scanners, scheduling replacement efforts before vulnerabilities emerge.
  • Negotiate support agreements for critical commercial components, verifying SLAs for patch delivery and incident response.
  • Isolate high-risk third-party integrations using anti-corruption layers or façade patterns to reduce coupling.
  • Enforce version pinning and dependency locking in build configurations to prevent untested transitive updates.

Module 6: Data Integrity and Consistency Across Systems

  • Choose between synchronous and asynchronous data synchronization based on consistency requirements and availability constraints.
  • Implement idempotency in data processing pipelines to handle duplicate messages from message brokers like Kafka or RabbitMQ.
  • Design compensating transactions for distributed operations where two-phase commit is not feasible.
  • Use database constraints and application-level checks to enforce referential integrity in polyglot persistence environments.
  • Define data retention and archival policies in coordination with legal and data governance teams, implementing automated purging.
  • Validate data quality at ingestion points using schema validation and anomaly detection, rejecting or quarantining malformed records.

Module 7: Team Autonomy and Cross-Team Coordination

  • Structure team boundaries around business capabilities rather than technical layers, minimizing handoffs and increasing ownership.
  • Establish shared interfaces for inter-team APIs using contract-first design and OpenAPI specifications with automated conformance testing.
  • Implement a change advisory board (CAB) process for high-impact system changes, requiring cross-team impact assessments.
  • Use feature flags to decouple deployment from release, enabling controlled rollouts and rollback without code reverts.
  • Standardize CI/CD pipeline templates across teams while allowing opt-in extensions for specialized needs.
  • Conduct regular cross-team architecture guild meetings to align on patterns, share lessons, and resolve integration conflicts.

Module 8: Evolution and Deprecation of Legacy Systems

  • Map dependencies between legacy and modern systems using code and traffic analysis to identify safe migration entry points.
  • Define deprecation timelines for APIs and services, communicating them through internal developer portals with usage metrics.
  • Implement strangler fig patterns to incrementally replace monolithic functionality with microservices behind a facade.
  • Freeze feature development on legacy systems to redirect resources toward modern replacements.
  • Design data migration strategies that support dual-write during transition, ensuring consistency across systems.
  • Decommission retired systems only after verifying no active dependencies and archiving audit-relevant data.
!