Building modular ALM and SRE tools around SAP with Python and open technologies.
This page documents the architecture, libraries, and reusable patterns behind a collection of independently developed ALM and reliability subapplications. The tools cover change analysis, operational review, SAP Cloud ALM integration, BPCA interpretation, short-dump assistance, Python application governance, browser automation, reporting, and guided workflows.
The examples are intentionally described at a technology and implementation-pattern level. Product names from SAP identify integration points and setup requirements; the application logic described here is independent software.
A lightweight application layer around enterprise systems.
The overall pattern is a Python/Flask control and analysis layer, a browser-facing UI, and governed adapters to SAP services. Each subtool can remain small and focused while sharing authentication, navigation, persistence, export, and deployment patterns.
Focused tools with reusable implementation patterns.
These are examples of the inner applications and the kinds of functions they contain. Several can run independently; the shared shell simply gives them a common navigation and deployment surface.
ChaRM CAB Dashboard
Loads change-governance data through OData or structured file fallbacks, normalizes fields, supports browser-side review and exports CSV/XLSX.
Reusable pieces: OData adapters, table normalization, editable review state, export pipelines.
SAP Cloud ALM Features Dashboard
Reads Cloud ALM feature and transport context, resolves project/release labels, and presents sortable operational views.
Reusable pieces: REST/OData client patterns, token handling, caching, resilient label resolution.
Shortdump Helper
Accepts ST22 HTML exports and turns them into structured findings with HTML, PDF, and JSON output.
Reusable pieces: BeautifulSoup parsing, rule/knowledge packs, ReportLab PDF generation.
BPCA Summary Writer
Processes BPCA intersection data, groups change impact, adds chronology/dependency context, and produces readable summaries.
Reusable pieces: pandas analysis, XLSX parsing, classification rules, visualization and report export.
Relative Impact Map
Builds transport-to-object relationship maps, identifies shared objects, and supports search/refocus across dependency hops.
Reusable pieces: graph-shaped data, deduplication, client-side filtering, interactive relationship exploration.
NAVICA
Analyzes object lists and optional catalogs to surface findings and create HTML/PDF/JSON reports.
Reusable pieces: parsers, scoring, mappings, lightweight persistence, structured exporters.
Import Queue Visualizer
Transforms CTS-style queue data into an ordered operational view and can simulate import progress for training/demo purposes.
Reusable pieces: legacy HTML/XLS parsing, sequence preservation, queue-state normalization, animated UI state.
Pre & Post Import Review
Reconciles pre-import change plans against post-import history and highlights warnings, errors, missing imports, and exceptions.
Reusable pieces: workbook correlation, reconciliation rules, evidence expansion, owner-facing Excel reporting.
PythonTestCockpit
Reviews Python application packages before governed publishing or deployment and returns structured code findings.
Reusable pieces: ZIP/repository inspection, policy gates, static Python analysis, HTML/JSON findings.
Python App Studio
A controlled single-file Python workspace with run/test, managed files, review workflow, restricted execution, notebook-style practice, and approved data services.
Reusable pieces: sandboxed execution, allow-listed imports, retention controls, publish/review lifecycle.
Python Deployment Cockpit
Guides approved Python packages through deployment checks and SAP BTP packaging expectations before creating a deployable artifact.
Reusable pieces: descriptor validation, readiness gates, packaging checks, repeatable deployment guidance.
ALM WebFlow Studio
Web-focused automation built around recording, object repositories, replay, data-driven execution, scheduling, audit, and an outbound-only local Chromium client.
Reusable pieces: Playwright, HMAC-signed client tasks, resilient selectors, audit trails, local/hosted runtime split.
Guided Tutorials & Engenie
A contextual help layer that can understand application manifests, launch guided procedures, and point users toward relevant tools or SAP references.
Reusable pieces: application manifests, guided-tour metadata, contextual state, provider-neutral assistant adapters.
Project & Release Timeline
Turns roadmap workbooks into interactive owner/status/lifecycle views with editable stages and standalone exports.
Reusable pieces: openpyxl/XlsxWriter workflows, client-side visualization, structured timeline modeling.
Local fallback runners
Where cloud-to-on-premise access is unavailable, a small governed local service can retrieve data and return only the required result.
Reusable pieces: bounded local agents, encrypted configuration, job leasing, controlled fallback behavior.
Libraries and what they are doing in practice.
| Technology | Role in the tools | Typical use |
|---|---|---|
| Python 3 | Primary application and analysis language. | Parsing, APIs, rules, automation, reports, data transformation. |
| Flask | Small web-service and server-rendered application layer. | Routes, uploads, exports, health endpoints, internal APIs. |
| pandas | Tabular normalization and analysis. | BPCA intersections, change datasets, reconciliation, filtering, aggregation. |
| openpyxl / XlsxWriter | Read and generate Excel workbooks. | Operational inputs, owner-facing reports, styled exports. |
| BeautifulSoup | HTML parsing. | ST22 exports and legacy HTML tables where an API is unavailable. |
| ReportLab | PDF generation. | Portable analysis reports and structured output. |
| matplotlib | Server-side chart generation where static graphics are useful. | Report visuals and analysis output. |
| requests | HTTP client layer. | SAP Cloud ALM APIs, OData endpoints, service-to-service calls. |
| PyJWT | JWT parsing/validation support. | Identity and authorization integration patterns. |
| boto3 | S3-compatible object persistence. | Durable application state and artifacts on supported object stores. |
| Playwright | Controlled Chromium recording and execution. | Web automation, replay, screenshots, synthetic checks. |
| psutil | Scoped local process management. | Cleaning up recorder/execution-owned Chromium processes safely. |
| JavaScript / HTML / CSS | Interactive user interface layer. | Tables, filters, layout persistence, drag/resize, guided tours, graph interactions. |
SAP BTP without hiding the plumbing.
For Cloud Foundry deployment, the useful pattern is to keep runtime configuration in SAP BTP services rather than source code. A typical setup combines a Python backend, SAP Application Router, XSUAA, Destination service, Connectivity service when on-premise access is needed, and Object Store where persistence is required.
Application Router + XSUAA
Use the router as the browser entry point, authenticate the user, and forward the authenticated request to the backend. Role checks should also be enforced server-side.
Destination + Connectivity
Keep backend endpoints and connection metadata in governed destinations. For private-network SAP systems, pair an OnPremise destination with SAP Connectivity service and Cloud Connector.
MTA packaging
Describe modules, resources, bindings, and dependencies in mta.yaml, then build a repeatable MTAR instead of hand-configuring each deployment.
Cloud ALM APIs
Consume published APIs through a narrow adapter layer so application code works with logical objects rather than embedding tenant-specific details throughout the UI.
Object persistence
Use shared object storage for durable state and keep transient uploads in memory where there is no reason to retain them.
Hybrid automation
Keep browser execution on an approved local client when the target application is inside a private network. Pair the client outbound-only and exchange signed task envelopes rather than creating a generic tunnel.
Setup material worth keeping beside the code.
These SAP Help Portal references cover the platform pieces used by this architecture. They are preferable to copying environment-specific setup values into project documentation.
Source examples and learning notes.
For smaller Python utilities and older experiments, the public workbench contains examples of SAP automation, RFC data access, reporting, and operational tooling. Think Like Python covers the progression from ABAP-oriented thinking into Python, Flask, SAP APIs and cloud deployment.
The site assistant can help point to the relevant project, library, or SAP integration topic.