Skip to main content

Application Maintenance in Application Management

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

This curriculum spans the breadth of application maintenance operations typically addressed over multiple workshops in enterprise IT organizations, covering the same scope of planning, execution, and governance activities found in ongoing internal capability programs for production support and system reliability.

Module 1: Defining Application Maintenance Strategy

  • Selecting between reactive, preventive, corrective, and adaptive maintenance models based on system criticality and business SLAs.
  • Aligning maintenance cadence with release management cycles in regulated environments such as finance or healthcare.
  • Establishing ownership boundaries between development teams and operations for post-deployment support.
  • Integrating technical debt tracking into maintenance planning using static analysis tools and code review outcomes.
  • Defining rollback procedures and fallback mechanisms for failed maintenance deployments.
  • Assessing the cost-benefit of maintaining legacy systems versus modernization or replacement.
  • Documenting maintenance scope to exclude feature development while ensuring clarity with stakeholders.
  • Coordinating with security teams to prioritize patching in alignment with vulnerability severity ratings.

Module 2: Maintenance Workflows and Ticketing Systems

  • Configuring Jira or ServiceNow workflows to distinguish between defect fixes, configuration updates, and environment corrections.
  • Setting escalation paths for production incidents that bypass standard change control under emergency protocols.
  • Implementing mandatory fields in ticketing systems to capture root cause, impacted components, and downtime duration.
  • Enforcing change advisory board (CAB) review thresholds based on system impact and user base size.
  • Mapping ticket categories to SLA timeframes for response and resolution across business hours and 24/7 support tiers.
  • Automating ticket creation from monitoring alerts while preventing alert fatigue through intelligent filtering.
  • Integrating deployment logs with ticket references to enable audit traceability.
  • Using historical ticket data to identify recurring issues and trigger architectural improvements.

Module 3: Patch Management and Version Control

  • Scheduling patch windows during low-usage periods while accounting for global user distribution.
  • Validating patch compatibility with dependent libraries and third-party integrations in staging environments.
  • Managing merge conflicts in version-controlled configuration files during concurrent maintenance activities.
  • Tagging production releases in Git with metadata linking to corresponding change tickets.
  • Rolling back patches using blue-green deployment strategies when post-deployment errors exceed thresholds.
  • Enforcing signed commits and branch protection rules to prevent unauthorized code changes.
  • Archiving deprecated versions with clear deprecation notices and end-of-support dates.
  • Coordinating patch deployment across microservices with interdependent API contracts.

Module 4: Monitoring and Performance Tuning

  • Setting dynamic thresholds for anomaly detection based on historical performance baselines.
  • Correlating application logs, metrics, and traces to isolate performance bottlenecks in distributed systems.
  • Identifying memory leaks in long-running services using heap dump analysis and profiling tools.
  • Adjusting thread pool sizes and connection limits in response to load testing results.
  • Filtering noise in monitoring alerts to focus on user-impacting metrics such as error rates and latency.
  • Implementing synthetic transactions to validate critical user journeys during maintenance downtime.
  • Using APM tools to track transaction traces across service boundaries in containerized environments.
  • Documenting performance degradation patterns to inform capacity planning and scaling policies.

Module 5: Database Maintenance and Schema Evolution

  • Scheduling index rebuilds and statistics updates during maintenance windows to minimize query performance impact.
  • Executing zero-downtime schema migrations using dual-write patterns and versioned data models.
  • Validating referential integrity after bulk data corrections or ETL job failures.
  • Managing backward compatibility when deprecating database columns used by downstream consumers.
  • Archiving historical data to cold storage while maintaining query access through unified views.
  • Coordinating database failover tests with application teams to validate connection resilience.
  • Encrypting sensitive data at rest and managing key rotation without disrupting active transactions.
  • Monitoring long-running queries and blocking sessions to prevent resource exhaustion.

Module 6: Security and Compliance in Maintenance

  • Embedding security scanning tools into CI/CD pipelines for dependency vulnerability detection.
  • Documenting access control changes during maintenance for SOX or HIPAA audit readiness.
  • Applying the principle of least privilege when granting temporary admin access for troubleshooting.
  • Validating that log retention policies comply with legal requirements across jurisdictions.
  • Conducting post-maintenance penetration tests after infrastructure or configuration changes.
  • Disabling unused APIs and endpoints during maintenance to reduce attack surface.
  • Ensuring encrypted transmission of patches and configuration files across networks.
  • Reporting security incidents related to maintenance activities through formal incident response channels.

Module 7: Disaster Recovery and Backup Integrity

  • Testing full application recovery from backups at least quarterly, including configuration and data.
  • Verifying backup consistency across distributed databases using checksum validation.
  • Documenting recovery time objectives (RTO) and recovery point objectives (RPO) per application tier.
  • Storing backups in geographically separate regions to mitigate regional outage risks.
  • Automating backup verification scripts to detect corruption or incomplete transfers.
  • Isolating backup systems from production networks to prevent ransomware propagation.
  • Rotating backup encryption keys and securely storing decryption procedures offline.
  • Coordinating failover drills with business units to validate continuity of critical processes.

Module 8: Vendor and Third-Party Maintenance Coordination

  • Negotiating SLAs with SaaS providers that include maintenance notification lead times and compensation clauses.
  • Validating vendor-provided patches in a controlled environment before deployment.
  • Mapping third-party API deprecation schedules to internal migration timelines.
  • Requiring vendors to provide audit logs for changes made to hosted components.
  • Managing license compliance during version upgrades enforced by external vendors.
  • Establishing secure communication channels for exchanging credentials and certificates with partners.
  • Documenting fallback mechanisms when third-party services are unavailable during maintenance.
  • Conducting due diligence on vendor security practices before integrating managed services.

Module 9: Continuous Improvement and Knowledge Management

  • Conducting blameless post-mortems after major incidents to update maintenance procedures.
  • Populating a knowledge base with runbooks for common troubleshooting scenarios and known errors.
  • Measuring mean time to repair (MTTR) and mean time between failures (MTBF) to assess maintenance effectiveness.
  • Rotating on-call responsibilities across team members to distribute expertise and prevent burnout.
  • Integrating feedback from support teams into backlog refinement for recurring issues.
  • Updating documentation automatically using code annotations and CI/CD pipeline outputs.
  • Archiving obsolete procedures with clear pointers to current practices to prevent confusion.
  • Using retrospectives to refine maintenance processes based on team velocity and incident trends.