Skip to main content
Back End

Back End

$490.00
Availability:
Downloadable Resources, Instant Access
When you get access:
Course access is prepared after purchase and delivered via email
Your guarantee:
30-day money-back guarantee — no questions asked
Who trusts this:
Trusted by professionals in 160+ countries
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.
How you learn:
Self-paced • Lifetime updates
Adding to cart… The item has been added

What does the Back End course cover?

Back End is covered here in 10 modules: Architectural Decision Frameworks for Scalable Systems, Data Management and Storage Strategy, API Design, Governance, and Lifecycle Management and 7 more. The outline lists 70 specific topics, opening with evaluate monolithic vs. microservices trade-offs in deployment velocity, team autonomy, and operational overhead.

How do you approach Back End step by step?

The work is sequenced in 10 stages. It starts with Architectural Decision Frameworks for Scalable Systems, moves through Data Management and Storage Strategy and API Design, Governance, and Lifecycle Management, and ends at Evolution and Modernization 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 Back End course?

Module 1 is Architectural Decision Frameworks for Scalable Systems. It works through evaluate monolithic vs. microservices trade-offs in deployment velocity, team autonomy, and operational overhead., assess event-driven architectures against request-response models for latency, consistency, and debugging complexity., define bounded contexts in domain-driven design to align service boundaries with business capabilities and ownership. and 4 more.

How is the Back End course delivered?

The Back End 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 Back End course cost?

The Back End course is $497 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.

Closely related courses: Back End Database, Back End Integration in Application Development, Back End Integration in Predictive Analytics Dataset, Back End Processing and Semiconductor Equipment.

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

This curriculum reflects the scope typically addressed across a full consulting engagement or multi-phase internal transformation initiative.

Module 1: Architectural Decision Frameworks for Scalable Systems

  • Evaluate monolithic vs. microservices trade-offs in deployment velocity, team autonomy, and operational overhead.
  • Assess event-driven architectures against request-response models for latency, consistency, and debugging complexity.
  • Define bounded contexts in domain-driven design to align service boundaries with business capabilities and ownership.
  • Model cross-cutting concerns such as logging, monitoring, and authentication across distributed components.
  • Balance consistency, availability, and partition tolerance based on business SLAs and failure recovery requirements.
  • Design for graceful degradation and circuit-breaking patterns under partial system failure.
  • Quantify technical debt accumulation from architectural shortcuts and establish repayment triggers.

Module 2: Data Management and Storage Strategy

  • Select appropriate database technologies (relational, document, graph, time-series) based on access patterns and consistency needs.
  • Design schema evolution strategies that support backward and forward compatibility in production systems.
  • Implement data retention, archiving, and purging policies aligned with regulatory and cost constraints.
  • Optimize indexing and query performance while managing write amplification and storage costs.
  • Establish data ownership and stewardship roles across business units and technical teams.
  • Design for data locality and replication across regions to meet latency and compliance requirements.
  • Assess trade-offs between embedded vs. normalized data models in distributed contexts.

Module 3: API Design, Governance, and Lifecycle Management

  • Define versioning strategies that minimize client disruption during backward-incompatible changes.
  • Specify contract-first design processes using OpenAPI or GraphQL schemas to enforce consistency.
  • Implement rate limiting, quotas, and throttling mechanisms based on consumer tiers and system capacity.
  • Enforce authentication, authorization, and audit logging at the API gateway and service levels.
  • Establish SLA definitions and monitor adherence across internal and external API consumers.
  • Manage deprecation timelines with clear communication, migration tooling, and sunset enforcement.
  • Balance flexibility and standardization in payload structure to reduce integration costs.

Module 4: Security and Compliance in Backend Systems

  • Implement zero-trust principles in service-to-service communication using mTLS and identity providers.
  • Design secure secret management workflows using vaults and rotation policies.
  • Map data flows to regulatory domains (e.g., GDPR, HIPAA) and enforce jurisdictional boundaries.
  • Conduct threat modeling for critical services using STRIDE or similar frameworks.
  • Integrate security scanning into CI/CD pipelines without introducing unacceptable build delays.
  • Define incident response protocols for data breaches, including forensic data preservation.
  • Validate third-party dependency risks through SBOM analysis and patch compliance tracking.

Module 5: Operational Resilience and Observability

  • Define meaningful service level indicators (SLIs) and objectives (SLOs) tied to business outcomes.
  • Instrument systems with structured logging, distributed tracing, and metrics collection at scale.
  • Configure alerting thresholds to minimize false positives while ensuring critical incidents are detected.
  • Design runbooks and escalation paths for common failure modes in production environments.
  • Implement canary deployments and feature flags to reduce blast radius of faulty releases.
  • Conduct blameless postmortems to identify systemic issues and track remediation actions.
  • Evaluate observability tooling (e.g., Prometheus, Jaeger, ELK) based on retention, cost, and query latency.

Module 6: Deployment Infrastructure and Platform Engineering

  • Compare managed Kubernetes, serverless, and VM-based platforms on cost, control, and scalability.
  • Design CI/CD pipelines with automated testing, security checks, and manual approval gates.
  • Manage infrastructure as code using GitOps practices with drift detection and audit trails.
  • Allocate compute resources with awareness of overprovisioning costs and performance headroom.
  • Standardize container base images and build processes to reduce attack surface and vulnerabilities.
  • Enforce environment parity across development, staging, and production to reduce configuration drift.
  • Evaluate platform team ROI by measuring developer lead time and incident resolution speed.

Module 7: Cost Optimization and Resource Governance

  • Attribute cloud spend to teams, services, and business units using tagging and allocation models.
  • Right-size compute instances and storage tiers based on utilization metrics and growth projections.
  • Implement auto-scaling policies that balance responsiveness with cost efficiency.
  • Negotiate reserved capacity and spot instance usage with risk tolerance for workload interruption.
  • Identify and decommission idle or orphaned resources through automated reporting.
  • Model cost implications of architectural decisions such as data replication and caching layers.
  • Establish budget alerts and approval workflows for unexpected expenditure spikes.

Module 8: Integration and Interoperability Strategy

  • Choose between synchronous and asynchronous integration patterns based on data consistency and latency needs.
  • Design idempotent message processors to handle duplicate or out-of-order events.
  • Implement data synchronization strategies across heterogeneous systems with conflict resolution logic.
  • Evaluate ESB vs. API gateway vs. direct service coupling for integration complexity and maintainability.
  • Manage schema compatibility in message queues using schema registry and validation.
  • Orchestrate long-running workflows with compensation logic for partial failure recovery.
  • Assess vendor lock-in risks when using proprietary integration platforms or messaging services.

Module 9: Strategic Technical Leadership and Decision Governance

  • Establish architecture review boards with clear decision rights and escalation paths.
  • Define technology lifecycle policies for adoption, support, and retirement of backend components.
  • Balance innovation velocity with standardization to avoid fragmentation and support burden.
  • Facilitate cross-functional alignment between product, security, operations, and development teams.
  • Quantify risk exposure from technical decisions using failure mode and impact analysis (FMEA).
  • Communicate technical trade-offs to non-technical stakeholders using business impact language.
  • Measure engineering effectiveness through DORA metrics while avoiding misuse as performance targets.

Module 10: Evolution and Modernization of Legacy Systems

  • Assess technical and business constraints that limit refactoring or replacement options.
  • Apply strangler pattern to incrementally migrate functionality from legacy to modern platforms.
  • Identify high-value integration points for exposing legacy data via APIs with transformation layers.
  • Manage coexistence of old and new systems with data consistency and transaction integrity.
  • Estimate total cost of ownership for maintaining legacy systems versus modernization investment.
  • Preserve business logic embedded in legacy code through careful reverse engineering and testing.
  • Secure stakeholder alignment on modernization timelines, risks, and interim operational overhead.
!