Initial commit

references/abap-cloud.md

@@ -0,0 +1,407 @@
+# ABAP Cloud Development Reference
+
+## Overview
+
+ABAP Cloud is SAP's cloud-ready development model for building extensible, maintainable applications in the SAP BTP ABAP Environment.
+
+## Foundational Technologies
+
+| Technology | Purpose |
+|------------|---------|
+| Core Data Services (CDS) | Data modeling, integrated analytics |
+| ABAP RESTful Application Programming Model (RAP) | Service-oriented application development |
+| Restricted ABAP Language | Cloud-safe development through controlled API access |
+| Released Public APIs | Upgrade-stable extensions |
+
+## Development Environment
+
+**Primary IDE**: ABAP Development Tools for Eclipse (ADT)
+
+**Additional Tools:**
+- ABAP Test Cockpit (ATC) - Static analysis
+- ABAP Unit - Dynamic testing
+- SAP Fiori Launchpad - UI deployment
+
+## Application Development Process
+
+### 6-Step Development Workflow
+
+| Step | Activity | Details |
+|------|----------|---------|
+| 1 | **Model the Domain** | Define domain-specific data models aligned with RAP architecture |
+| 2 | **Implement Business Behavior** | Add validations, determinations, actions, consistency management |
+| 3 | **Expose Services** | Define and bind services via OData |
+| 4 | **Secure Access** | Configure authorization, assign proper scopes and roles |
+| 5 | **Build the UI** | Develop SAP Fiori applications consuming services |
+| 6 | **Ensure Quality** | Add automated tests and static checks |
+
+### Development Approaches
+
+**Develop from Scratch:**
+- Build new applications and services using RAP blueprint
+- Domain-specific data models with extensibility built-in
+
+**Extend Existing Services:**
+- Extend SAP or custom services in upgrade-safe way
+- Opt-in extensibility: original data models must explicitly enable each option
+
+### S/4HANA Extension Options
+
+| Type | Description | Use Case |
+|------|-------------|----------|
+| **On-Stack** | Extensions run within S/4HANA Cloud, share database and lifecycle | Tight integration, key-user extensibility (low-code), developer extensibility (pro-code) |
+| **Side-by-Side** | Extensions run on SAP BTP with separate runtime and lifecycle | Loosely coupled solutions, partner offerings, hub scenarios |
+
+### Test Strategy
+
+**Automated Testing** is essential for reliability, stability, and quality:
+
+- **Unit Tests**: ABAP Unit for functional correctness
+- **Integration Tests**: Cross-component validation
+- **Static Analysis**: ABAP Test Cockpit (ATC)
+
+### Development Recommendations
+
+1. Connect ABAP Cloud systems to Eclipse with ABAP Development Tools
+2. Build OData services using RAP optimized for SAP HANA Cloud
+3. Perform static code analysis with ATC including Code Vulnerability Analyzer
+4. Use central ATC on SAP BTP for custom code governance
+5. Leverage the Analyze Custom Code application for code inspection
+
+## Model-Driven Architecture
+
+### Three-Tier Structure
+1. **Data Access Layer** - Database tables, CDS views
+2. **Domain Model Layer** - Business logic, validations
+3. **Service Exposure Layer** - OData services, Web APIs
+
+### Benefits
+- Faster delivery via standardized stacks
+- Interoperability through consistent rules
+- Multipurpose CDS models (transactional + analytical)
+
+## CDS Data Modeling
+
+### Basic Entity Definition
+```abap
+@EndUserText.label: 'Travel'
+@AccessControl.authorizationCheck: #NOT_REQUIRED
+define root view entity ZI_Travel
+  as select from ztravel
+{
+  key travel_uuid       as TravelUUID,
+      travel_id         as TravelID,
+      agency_id         as AgencyID,
+      customer_id       as CustomerID,
+      begin_date        as BeginDate,
+      end_date          as EndDate,
+      booking_fee       as BookingFee,
+      total_price       as TotalPrice,
+      currency_code     as CurrencyCode,
+      description       as Description,
+      overall_status    as OverallStatus,
+      @Semantics.user.createdBy: true
+      created_by        as CreatedBy,
+      @Semantics.systemDateTime.createdAt: true
+      created_at        as CreatedAt,
+      @Semantics.user.lastChangedBy: true
+      last_changed_by   as LastChangedBy,
+      @Semantics.systemDateTime.lastChangedAt: true
+      last_changed_at   as LastChangedAt
+}
+```
+
+### Projection View for UI
+```abap
+@EndUserText.label: 'Travel Projection'
+@AccessControl.authorizationCheck: #NOT_REQUIRED
+@Metadata.allowExtensions: true
+define root view entity ZC_Travel
+  provider contract transactional_query
+  as projection on ZI_Travel
+{
+  key TravelUUID,
+      TravelID,
+      AgencyID,
+      CustomerID,
+      BeginDate,
+      EndDate,
+      BookingFee,
+      TotalPrice,
+      CurrencyCode,
+      Description,
+      OverallStatus,
+      CreatedBy,
+      CreatedAt,
+      LastChangedBy,
+      LastChangedAt
+}
+```
+
+## RAP Business Object Definition
+
+### Behavior Definition
+```abap
+managed implementation in class zbp_i_travel unique;
+strict ( 2 );
+
+define behavior for ZI_Travel alias Travel
+persistent table ztravel
+lock master
+authorization master ( instance )
+etag master LastChangedAt
+{
+  // Standard operations
+  create;
+  update;
+  delete;
+
+  // Field controls
+  field ( readonly ) TravelUUID, TravelID, CreatedBy, CreatedAt, LastChangedBy, LastChangedAt;
+  field ( mandatory ) AgencyID, CustomerID;
+
+  // Determinations
+  determination setTravelID on modify { create; }
+  determination calculateTotalPrice on modify { field BookingFee; }
+
+  // Validations
+  validation validateCustomer on save { field CustomerID; }
+  validation validateDates on save { field BeginDate, EndDate; }
+
+  // Actions
+  action acceptTravel result [1] $self;
+  action rejectTravel result [1] $self;
+
+  // Factory action
+  factory action copyTravel [1];
+
+  // Draft handling
+  draft action Edit;
+  draft action Activate optimized;
+  draft action Discard;
+  draft action Resume;
+  draft determine action Prepare;
+}
+```
+
+### Behavior Implementation
+```abap
+CLASS zbp_i_travel DEFINITION PUBLIC ABSTRACT FINAL
+  FOR BEHAVIOR OF zi_travel.
+ENDCLASS.
+
+CLASS zbp_i_travel IMPLEMENTATION.
+
+  METHOD setTravelID.
+    " Get max Travel ID
+    SELECT MAX( travel_id ) FROM ztravel INTO @DATA(lv_max_id).
+
+    " Set Travel ID for new entities
+    MODIFY ENTITIES OF zi_travel IN LOCAL MODE
+      ENTITY Travel
+        UPDATE FIELDS ( TravelID )
+        WITH VALUE #( FOR key IN keys
+          ( %tky = key-%tky
+            TravelID = lv_max_id + 1 ) ).
+  ENDMETHOD.
+
+  METHOD validateDates.
+    READ ENTITIES OF zi_travel IN LOCAL MODE
+      ENTITY Travel
+        FIELDS ( BeginDate EndDate )
+        WITH CORRESPONDING #( keys )
+      RESULT DATA(lt_travels).
+
+    LOOP AT lt_travels INTO DATA(ls_travel).
+      IF ls_travel-BeginDate > ls_travel-EndDate.
+        APPEND VALUE #( %tky = ls_travel-%tky ) TO failed-travel.
+        APPEND VALUE #( %tky = ls_travel-%tky
+                        %msg = new_message_with_text(
+                          severity = if_abap_behv_message=>severity-error
+                          text = 'End date must be after begin date' )
+                      ) TO reported-travel.
+      ENDIF.
+    ENDLOOP.
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+## Service Definition and Binding
+
+### Service Definition
+```abap
+@EndUserText.label: 'Travel Service Definition'
+define service ZUI_TRAVEL_O4 {
+  expose ZC_Travel as Travel;
+}
+```
+
+### Service Binding
+Create via ADT: OData V4 - UI binding type
+
+## Extensibility Options
+
+### Developer Extensibility
+- Custom fields and nodes
+- Custom business logic
+- ABAP Development Tools required
+
+### Key User Extensibility (Multitenant SaaS)
+- UI adaptations
+- Custom fields
+- Business Add-Ins (BAdIs)
+- No coding required
+
+## Reuse Services
+
+Pre-built building blocks available:
+- Application Jobs
+- Application Logging
+- Forms (Adobe Document Services)
+- Emails
+- Change Documents
+- Workflow (SAP Build Process Automation)
+- Number Ranges
+
+## Transport Mechanisms
+
+### gCTS (Recommended)
+- Modern transport for BTP systems within same global account
+- Managed via "Manage Software Components" app
+- Automatic Git repository management
+
+### abapGit
+- Open-source Git client
+- Use cases:
+  - Migrate on-premise code to cloud
+  - System decommissioning (export/import)
+  - Cross-account code transfers
+- **Not recommended** for standard production transports
+
+## Quality Assurance
+
+### ABAP Test Cockpit (ATC)
+
+**Default Variant**: `ABAP_CLOUD_DEVELOPMENT_DEFAULT`
+
+**Check Categories:**
+- Approved enhancement technologies
+- API usage governance
+- Critical ABAP statement analysis
+- Code Vulnerability Analyzer (optional)
+
+**Blocking Mode:**
+Configure to prevent Priority 1/2 findings from transport
+
+### ABAP Unit Testing
+```abap
+CLASS ltcl_travel DEFINITION FINAL FOR TESTING
+  DURATION SHORT
+  RISK LEVEL HARMLESS.
+
+  PRIVATE SECTION.
+    DATA: mo_cut TYPE REF TO zcl_travel_handler.
+
+    METHODS setup.
+    METHODS test_date_validation FOR TESTING.
+ENDCLASS.
+
+CLASS ltcl_travel IMPLEMENTATION.
+
+  METHOD setup.
+    mo_cut = NEW #( ).
+  ENDMETHOD.
+
+  METHOD test_date_validation.
+    " Given
+    DATA(lv_begin) = cl_abap_context_info=>get_system_date( ).
+    DATA(lv_end) = lv_begin + 7.
+
+    " When
+    DATA(lv_valid) = mo_cut->validate_dates(
+      iv_begin = lv_begin
+      iv_end = lv_end
+    ).
+
+    " Then
+    cl_abap_unit_assert=>assert_true( lv_valid ).
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+## Elastic Scaling
+
+### ABAP Compute Units (ACUs)
+- Manual scaling via BTP Cockpit
+- Automatic elastic scaling (0.5 ACU increments)
+- Metrics: CPU, memory, work process counts
+
+### HANA Compute Units (HCUs)
+- Manual adjustment with near-zero downtime
+- Native Storage Extension for cost optimization
+
+## System Hibernation
+
+**Benefits:**
+- Reduces costs to <5% of operational expenses
+- Preserves HANA Cloud instance
+- Automatic restart during scheduled maintenance
+
+**Management:**
+- Via Landscape Portal
+- Scheduling available (except trial accounts)
+
+## SAP Joule Integration
+
+**AI Capabilities:**
+1. Predictive code completion
+2. Joule chat (natural language)
+3. Code explanation
+4. ABAP Unit generation
+5. CDS test generation
+
+**ABAP AI SDK:**
+- Standardized access to language models on SAP AI Core
+- Intelligent Scenario Lifecycle Management
+
+## Partner Deployment Models
+
+### Multitenant SaaS
+- Cloud service in partner's global account
+- Customers subscribe
+- Partner manages operations
+- Key user extensibility for customers
+
+### Add-on Product
+- Installed in customer's ABAP environment
+- Customer manages lifecycle
+- Developer extensibility available
+- Requires SAP PartnerEdge Build contract
+
+### Requirements
+- Registered ABAP namespace (mandatory)
+- Software Components for transport
+- Landscape Portal for lifecycle management
+
+## Upgrade Management
+
+### Downtime-Optimized Upgrades
+1. **Preparation**: New release in shadow layer (system available)
+2. **Takeover**: 10-40 minutes downtime
+3. **Postprocessing**: Background cleanup (system available)
+
+### Pre-Upgrade Option
+- Test on non-production 4 weeks before release
+- Validate custom applications
+- Report issues through SAP support
+
+## Source Documentation
+
+- ABAP Environment: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-abap-environment-with-abap-cloud-174b229.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-abap-environment-with-abap-cloud-174b229.md)
+- ABAP Cloud Development: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/developing-with-abap-cloud-in-the-sap-btp-abap-environment-9aaaf65.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/developing-with-abap-cloud-in-the-sap-btp-abap-environment-9aaaf65.md)
+- Elastic Scaling: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/benefit-from-the-elastic-scaling-of-abap-application-servers-c1d35c5.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/benefit-from-the-elastic-scaling-of-abap-application-servers-c1d35c5.md)
+- System Hibernation: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/use-system-hibernation-6a8d7ee.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/use-system-hibernation-6a8d7ee.md)
+- ATC Governance: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/keep-clean-core-governance-with-abap-test-cockpit-698ddfa.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/keep-clean-core-governance-with-abap-test-cockpit-698ddfa.md)
+- Joule: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/use-joule-for-developers-generative-ai-in-abap-cloud-63c8ac1.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/use-joule-for-developers-generative-ai-in-abap-cloud-63c8ac1.md)

references/architecture.md

@@ -0,0 +1,166 @@
+# SAP BTP Architecture Reference
+
+## Platform Overview
+
+SAP BTP provides a three-tier architecture:
+- **Presentation Layer**: SAP Fiori/SAPUI5 frontends
+- **Logic Layer**: CAP (Node.js/Java) or ABAP Cloud
+- **Persistence Layer**: SAP HANA Cloud
+
+**Data Protocols:**
+- OData (transactional data)
+- InA (analytical data)
+
+## Core Services Catalog
+
+### Persistence & Data
+
+| Service | Purpose | Details |
+|---------|---------|---------|
+| SAP HANA Cloud | Database-as-a-Service | Relational, document, geospatial, vector data |
+| HANA Data Lake Files | Object storage | Large-scale data storage |
+| SAP Datasphere | Cross-application analytics | Data federation and warehousing |
+
+**HANA Cloud Optimization Features:**
+
+| Feature | Description | Free/Trial | Paid |
+|---------|-------------|------------|------|
+| **Native Storage Extension (NSE)** | Store infrequently accessed data on disk | No | Yes |
+| **Elastic Compute Nodes (ECN)** | On-demand scaling for peak workloads | No | Yes |
+| **Table Partitioning** | Enhanced query performance | Limited | Yes |
+| **Native Multi-Tenancy** | Up to 1,000 isolated tenants per instance | No | Yes |
+| **Free Tier** | 16GB memory at no cost | Yes (16GB) | N/A |
+
+> **Note**: Feature availability varies by plan. See [SAP HANA Cloud Capacity Units](https://help.sap.com/docs/hana-cloud/sap-hana-cloud-administration-guide/capacity-units) for detailed tier comparison.
+
+### Integration Services
+
+| Service | Purpose | Supported Scenarios |
+|---------|---------|---------------------|
+| SAP Event Mesh | Event distribution | Cross-application eventing |
+| SAP Integration Suite | API Management, Cloud Integration | B2B, A2A, API publishing |
+| SAP Master Data Integration | Central data hub | SAP One Domain Model |
+| Cloud Integration Automation | Guided workflows | Automated integration setup |
+
+### Identity & Security
+
+| Service | CAP | ABAP |
+|---------|-----|------|
+| SAP Authentication and Trust Management | Yes | Yes |
+| Identity Authentication | Yes (SSO, on-prem) | Yes (SSO, on-prem) |
+| SAP Credential Store | Yes (secrets via REST) | Communication Management |
+| SAP Audit Log Service | Yes | Security audit logging |
+| Identity Provisioning | Yes | Yes (business user provisioning) |
+
+### Workflow & Automation
+
+| Service | Purpose |
+|---------|---------|
+| SAP Task Center | Unified inbox across applications |
+| SAP Build Process Automation | Workflow, RPA, decision management |
+| SAP Job Scheduling Service | REST APIs, recurring schedules (CAP) |
+| Application Jobs | Integrated scheduling (ABAP) |
+
+### Observability
+
+| Service | Purpose |
+|---------|---------|
+| SAP Cloud ALM | Central monitoring (RUM, health, integration) |
+| SAP Cloud Logging | Logs, metrics, traces (OpenSearch-based) |
+| SAP Alert Notification | Event subscriptions, multi-channel delivery |
+| Technical Monitoring Cockpit | ABAP on-stack analysis |
+
+### Extensibility Services
+
+| Service | Purpose |
+|---------|---------|
+| SAP S/4HANA Cloud Extensibility | Side-by-side extensions |
+| SAP SuccessFactors Extensibility | HR solution extensions |
+| SAP Build Work Zone | Business sites, central entry point |
+
+## Client Libraries
+
+### CAP (Non-ABAP)
+- **SAP Cloud SDK**: OData/OpenAPI clients, Destination, Connectivity services
+- **Languages**: Java (Spring Boot), JavaScript, TypeScript (Node.js)
+- **Guaranteed Node.js/Java version compatibility**
+
+### ABAP
+- **Service Consumption Model**: Generates local APIs for OData, SOAP, RFC
+- **Communication Management**: System integration with credentials
+- **Native RAP event support**
+
+## User Interface Options
+
+### Web Development
+| Approach | Description | Use When |
+|----------|-------------|----------|
+| SAP Fiori Elements | Predefined templates (List Report, Object Page) | Standard business apps |
+| Flexible Programming Model | Fiori Elements + custom extensions | Selective customization |
+| Freestyle SAPUI5 | Full UI control | Highly custom interfaces |
+
+### Mobile Development
+| SDK | Platform |
+|-----|----------|
+| SAP Mobile Development Kit | Cross-platform |
+| SAP BTP SDK for Android | Android native |
+| SAP BTP SDK for iOS | iOS native |
+
+Features: Offline sync, push notifications, mobile security
+
+## Central Access Points
+
+| Application Type | Entry Point |
+|-----------------|-------------|
+| CAP Applications | SAP Build Work Zone, HTML5 Repository |
+| ABAP Applications | SAP Fiori Launchpad for BTP ABAP Environment |
+
+## Analytics Capabilities
+
+### CAP
+- SAP Analytics Cloud (embedded dashboards)
+- SAP Datasphere (cross-application analytics)
+
+### ABAP
+- SAP Analytics Cloud on InA-enabled CDS models
+- Dragonfly-based multidimensional reporting
+- SAP Datasphere via ABAP SQL Service
+
+## System Landscape Management
+
+### Unified Customer Landscape
+- Auto-discovery of associated systems
+- Manual system registration
+- Support for S/4HANA, Ariba, SuccessFactors, third-party
+
+### ABAP-Specific
+- Landscape Portal for system hibernation
+- Pre-upgrade nomination for quarterly releases
+
+## Low-Code/No-Code Options
+
+**SAP Build Suite:**
+- SAP Build Apps (enterprise applications)
+- SAP Build Process Automation (workflow, RPA)
+- SAP Build Work Zone (business sites)
+- Prebuilt connectors for SAP and third-party
+
+## Infrastructure Automation
+
+| Tool | Purpose |
+|------|---------|
+| Terraform Provider for SAP BTP | Resource provisioning automation |
+| SAP Automation Pilot | Operational task automation, database lifecycle |
+
+## Key Design Principles
+
+1. **API-First**: Follow SAP Business Accelerator Hub guidelines
+2. **Compliance**: Accessibility, theming for all UI components
+3. **Observability**: Central unified operations experience
+4. **Consistency**: Unified solution experience across customer base
+5. **Enterprise Standards**: Prefer SAP BTP services over custom solutions
+
+## Source Documentation
+
+- Understanding Available Technology: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/understanding-available-technology-c1f21a4.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/understanding-available-technology-c1f21a4.md)
+- Tools Available: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tools-available-for-sap-btp-multi-cloud-foundation-7f95cfa.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tools-available-for-sap-btp-multi-cloud-foundation-7f95cfa.md)

references/cap-development.md

@@ -0,0 +1,374 @@
+# CAP Development Reference
+
+## Overview
+
+SAP Cloud Application Programming Model (CAP) is SAP's recommended framework for building enterprise-grade applications on SAP BTP using Node.js or Java.
+
+## Operational Profiles
+
+CAP provides three operational profiles for different development stages:
+
+### Development Profile
+
+**Database**: SQLite (Node.js) / H2 (Java)
+
+**Features:**
+- Rapid prototyping with minimal setup
+- Mocked variants of SAP BTP services (authentication, database, messaging, app gateway)
+- No BTP subscription required
+- Cost-effective testing
+
+**Usage:**
+```bash
+cds watch  # Automatically uses development profile
+```
+
+### Hybrid Profile
+
+**Database**: Cloud services (e.g., SAP HANA Cloud)
+
+**Features:**
+- Run application locally
+- Bind to real cloud services for integration testing
+- Use `cds bind` or local configuration files
+- Test with production-like data
+
+**Usage:**
+```bash
+cds bind --to hana:my-hana-instance
+cds watch --profile hybrid
+```
+
+### Production Profile
+
+**Database**: SAP HANA Cloud
+
+**Features:**
+- Deployed to SAP BTP (Cloud Foundry or Kyma)
+- Platform-managed service bindings
+- Production configuration for logging and security
+- Database migrations via `cds deploy`
+
+**Usage:**
+```bash
+cds build --production
+cf deploy mta_archives/my-app.mtar
+```
+
+### Profile Summary
+
+| Profile | Database | Use Case |
+|---------|----------|----------|
+| Development | SQLite/H2 | Local prototyping, mock services |
+| Hybrid | Cloud services | Local app with cloud DB/services |
+| Production | SAP HANA Cloud | Full cloud deployment |
+
+## Supported Languages and Runtimes
+
+| Language | Framework | Runtime Options |
+|----------|-----------|-----------------|
+| Node.js | Express.js | Cloud Foundry, Kyma |
+| Java | Spring Boot | Cloud Foundry, Kyma |
+| TypeScript | Node.js | Cloud Foundry, Kyma |
+
+## Development Tools
+
+| Tool | Purpose |
+|------|---------|
+| SAP Business Application Studio | Primary cloud IDE |
+| Visual Studio Code | Local development with CDS extension |
+| IntelliJ IDEA | Java CAP development |
+| CDS CLI | Command-line development |
+
+## Core CDS Commands
+
+```bash
+# Initialize new project
+cds init my-project
+
+# Add features
+cds add hana          # SAP HANA Cloud support
+cds add xsuaa         # Authentication
+cds add mta           # MTA descriptor
+cds add helm          # Helm charts for Kyma
+cds add multitenancy  # Multitenant support
+cds add approuter     # Application router
+
+# Development
+cds watch             # Run with live reload
+cds build             # Build for deployment
+cds deploy            # Deploy to HANA
+
+# Service inspection
+cds compile           # Compile CDS models
+cds serve             # Start services
+```
+
+## Domain Modeling with CDS
+
+### Entity Definition
+```cds
+namespace my.bookshop;
+
+entity Books {
+  key ID : UUID;
+  title  : String(111);
+  author : Association to Authors;
+  stock  : Integer;
+}
+
+entity Authors {
+  key ID : UUID;
+  name   : String(111);
+  books  : Association to many Books on books.author = $self;
+}
+```
+
+### Service Definition
+```cds
+using my.bookshop from '../db/schema';
+
+service CatalogService {
+  @readonly entity Books as projection on bookshop.Books;
+  entity Authors as projection on bookshop.Authors;
+
+  action submitOrder(book: Books:ID, quantity: Integer);
+}
+```
+
+## CAP Design Principles
+
+### Domain-Driven Design
+- Focus on core domain logic
+- Align code structure with business concepts
+- Collaboration between technical and domain experts
+
+### Agnostic Design
+CAP abstracts:
+- Deployment approaches
+- Authentication strategies
+- Protocols (REST, OData, GraphQL)
+- Asynchronous channels
+- Database technologies
+
+### Out-of-the-Box Integration
+- SAP HANA Cloud for persistence
+- Authorization management services
+- Connectivity tools for external systems
+
+## Platform Integration
+
+### Database Support
+| Database | Use Case |
+|----------|----------|
+| SQLite | Development (Node.js) |
+| H2 | Development (Java) |
+| PostgreSQL | Production alternative |
+| SAP HANA Cloud | Production (recommended) |
+
+### Service Bindings
+```yaml
+# mta.yaml service binding example
+modules:
+  - name: my-srv
+    type: nodejs
+    requires:
+      - name: my-hana
+      - name: my-xsuaa
+      - name: my-destination
+
+resources:
+  - name: my-hana
+    type: com.sap.xs.hdi-container
+  - name: my-xsuaa
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      service-plan: application
+```
+
+## Microservices Architecture
+
+CAP supports microservice development with:
+- Separate lifecycles per service
+- Independent runtimes
+- Event-based communication
+
+**Considerations:**
+- Microservices introduce complexity
+- Potential performance trade-offs
+- Start monolithic, extract when needed
+
+## API Consumption
+
+### Supported Protocols
+- OData V2/V4
+- REST
+- OpenAPI
+
+### SAP Cloud SDK Integration
+
+**Generate typed client** (recommended approach):
+```bash
+# Generate OData client from service specification
+npx @sap-cloud-sdk/generator --input ./API_BUSINESS_PARTNER.edmx --outputDir ./generated
+```
+
+**Use generated client**:
+```javascript
+// Import from generated client (path depends on generator output)
+const { businessPartnerApi } = require('./generated/business-partner-service');
+
+// Fetch business partners from S/4HANA
+const businessPartners = await businessPartnerApi
+  .requestBuilder()
+  .getAll()
+  .execute({ destinationName: 'S4HANA' });
+```
+
+> **Note**: The `@sap/cloud-sdk-vdm-*` packages are deprecated. Use `@sap-cloud-sdk/generator` to generate typed clients from OData service specifications. See [SAP Cloud SDK documentation](https://sap.github.io/cloud-sdk/docs/js/features/odata/generate-client) for details.
+
+## Multitenancy
+
+### Enable Multitenancy
+```bash
+cds add multitenancy
+```
+
+### Key Features
+- Tenant isolation
+- Per-tenant database schemas
+- Subscription lifecycle hooks
+- Resource sharing across tenants
+
+### SaaS Entry Points
+
+| Approach | Description | Consumer Requirements |
+|----------|-------------|----------------------|
+| Central | SAP Build Work Zone managed | Own Work Zone instance |
+| Local | Standalone app router | None |
+
+## Extensibility
+
+### In-App Extensions
+```cds
+// Extend existing service
+extend service CatalogService with {
+  entity CustomEntity {
+    key ID : UUID;
+    customField : String;
+  }
+}
+```
+
+### Custom Handlers
+```javascript
+// srv/cat-service.js
+module.exports = (srv) => {
+  srv.before('CREATE', 'Books', async (req) => {
+    // Validation logic
+    if (!req.data.title) {
+      req.error(400, 'Title is required');
+    }
+  });
+
+  srv.on('submitOrder', async (req) => {
+    // Custom action implementation
+    const { book, quantity } = req.data;
+    // Process order...
+  });
+};
+```
+
+## Security Implementation
+
+### Authentication
+```cds
+// Require authentication
+service CatalogService @(requires: 'authenticated-user') {
+  entity Books as projection on bookshop.Books;
+}
+```
+
+### Authorization
+```cds
+// Role-based access
+service AdminService @(requires: 'admin') {
+  entity Books as projection on bookshop.Books;
+
+  @(restrict: [{ grant: 'READ', to: 'viewer' }])
+  entity Reports { ... }
+}
+```
+
+### Built-in Security Features
+- Parameterized queries (SQL injection prevention)
+- CSRF protection for UI applications
+- CDS constraints for input validation
+
+## Testing
+
+### Unit Testing with Jest
+```javascript
+const cds = require('@sap/cds');
+
+describe('CatalogService', () => {
+  let srv;
+
+  beforeAll(async () => {
+    srv = await cds.connect.to('CatalogService');
+  });
+
+  it('should return books', async () => {
+    const books = await srv.read('Books');
+    expect(books).toBeDefined();
+  });
+});
+```
+
+### Integration Testing
+```bash
+# Run tests
+npm test
+
+# With coverage
+npm test -- --coverage
+```
+
+## Deployment Commands
+
+### Cloud Foundry
+```bash
+# Build MTA
+mbt build
+
+# Deploy
+cf deploy mta_archives/my-project_1.0.0.mtar
+
+# Or with cf push for simple apps
+cf push
+```
+
+### Kyma
+```bash
+# Add Helm support
+cds add helm
+
+# Deploy with Helm
+helm upgrade --install my-app ./chart
+```
+
+## Common Issues and Solutions
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| `HANA deployment fails` | Wrong HDI container | Verify `requires` in mta.yaml |
+| `Authentication errors` | XSUAA not bound | Run `cf bind-service` |
+| `Database connection refused` | Wrong profile | Set `NODE_ENV=production` |
+| `Model compilation errors` | CDS syntax | Run `cds compile --to json` for details |
+
+## Source Documentation
+
+- CAP Documentation: [https://cap.cloud.sap/docs/](https://cap.cloud.sap/docs/)
+- SAP BTP CF/Kyma with CAP: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-cloud-foundry-and-sap-btp-kyma-runtimes-with-cap-0f9cfe9.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-cloud-foundry-and-sap-btp-kyma-runtimes-with-cap-0f9cfe9.md)
+- Development Guide: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/develop-7e30686.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/develop-7e30686.md)

references/cicd.md

@@ -0,0 +1,338 @@
+# SAP BTP CI/CD Reference
+
+## Overview
+
+Continuous Integration (CI) and Continuous Delivery (CD) are complementary DevOps practices that automate application development, testing, and deployment on SAP BTP.
+
+## Core Concepts
+
+### Continuous Integration (CI)
+- Frequent code integration into central repository
+- Automated builds and tests on each commit
+- Early error detection
+- Prevents integration problems from accumulating
+
+### Continuous Delivery (CD)
+- Extends CI with deployment automation
+- Successfully tested changes ready for production
+- Code built, tested, and packaged in deployable format
+- Deploy at management's discretion
+
+## SAP Continuous Integration and Delivery
+
+**Service Type**: BTP-native service with pre-configured pipelines
+
+### Advantages
+
+| Feature | Benefit |
+|---------|---------|
+| Simplicity | Out-of-the-box pipelines, minimal configuration |
+| Flexibility | Customizable pipelines, additional commands |
+| Infrastructure | Built-in management, no server maintenance |
+| SAP-Specific | Optimized for SAP technologies |
+
+### Supported Pipeline Types
+
+| Pipeline | Use Case |
+|----------|----------|
+| Cloud Foundry Environment | SAP Fiori, CAP applications |
+| SAP Fiori for ABAP Platform | Fiori apps on ABAP |
+| SAP Integration Suite Artifacts | Integration content |
+
+## Setup Process
+
+### Step 1: Enable Service
+
+1. Open SAP BTP Cockpit
+2. Navigate to subaccount
+3. Enable "Continuous Integration & Delivery"
+4. Subscribe to the service
+
+### Step 2: Assign Roles
+
+| Role | Permissions |
+|------|-------------|
+| Administrator | Full access, job management |
+| Developer | Create/run jobs, view results |
+
+### Step 3: Configure Repository Credentials
+
+**Supported Repositories:**
+- GitHub
+- GitLab
+- Bitbucket
+- Azure Repos
+
+```yaml
+# Example credential configuration
+credentials:
+  - name: github-credentials
+    type: basic
+    username: ${GITHUB_USER}
+    password: ${GITHUB_TOKEN}
+```
+
+### Step 4: Create CI/CD Job
+
+```yaml
+# .pipeline/config.yml for CAP application
+general:
+  projectName: my-cap-app
+  buildTool: mta
+
+stages:
+  Build:
+    mtaBuildParameters:
+      platform: cf
+
+  Additional Unit Tests:
+    npmExecuteScripts: true
+    npmScripts: ['test']
+
+  Release:
+    cloudFoundryDeploy: true
+    cfApiEndpoint: [https://api.cf.eu10.hana.ondemand.com](https://api.cf.eu10.hana.ondemand.com)
+    cfOrg: my-org
+    cfSpace: my-space
+    mtarFilePath: mta_archives/my-cap-app.mtar
+```
+
+### Step 5: Configure Webhooks
+
+Automate builds on push:
+1. Copy webhook URL from CI/CD service
+2. Add webhook in repository settings
+3. Select events (push, pull request)
+
+## Pipeline Configuration
+
+### CAP Node.js Pipeline
+
+```yaml
+# .pipeline/config.yml
+general:
+  buildTool: mta
+
+stages:
+  Build:
+    mtaBuildParameters:
+      platform: cf
+
+  Additional Unit Tests:
+    npmExecuteScripts: true
+    npmScripts:
+      - test
+
+  Acceptance:
+    cfDeploy: true
+    cloudFoundryDeploy: true
+    cfApiEndpoint: [https://api.cf.eu10.hana.ondemand.com](https://api.cf.eu10.hana.ondemand.com)
+    cfOrg: my-org
+    cfSpace: dev
+
+  Release:
+    cfDeploy: true
+    cloudFoundryDeploy: true
+    cfApiEndpoint: [https://api.cf.eu10.hana.ondemand.com](https://api.cf.eu10.hana.ondemand.com)
+    cfOrg: my-org
+    cfSpace: prod
+```
+
+### CAP Java Pipeline
+
+```yaml
+general:
+  buildTool: mta
+
+stages:
+  Build:
+    mtaBuildParameters:
+      platform: cf
+    mavenExecuteStaticCodeChecks: true
+
+  Additional Unit Tests:
+    mavenExecute: true
+    goals: ['test']
+```
+
+### SAP Fiori Pipeline
+
+```yaml
+general:
+  buildTool: npm
+
+stages:
+  Build:
+    npmExecuteScripts: true
+    npmScripts: ['build']
+
+  Additional Unit Tests:
+    npmExecuteScripts: true
+    npmScripts: ['test']
+    karmaExecuteTests: true
+```
+
+## ABAP CI/CD
+
+### gCTS Integration
+
+```yaml
+# Pipeline for ABAP Cloud
+stages:
+  Import:
+    abapEnvironmentPullGitRepo: true
+    repositoryName: my-software-component
+
+  Test:
+    abapEnvironmentRunATCCheck: true
+    atcConfig:
+      checkVariant: ABAP_CLOUD_DEVELOPMENT_DEFAULT
+
+  Release:
+    abapEnvironmentAssembleConfirm: true
+```
+
+### ATC Integration
+
+```yaml
+stages:
+  Quality:
+    abapEnvironmentRunATCCheck: true
+    atcConfig:
+      checkVariant: ABAP_CLOUD_DEVELOPMENT_DEFAULT
+      failOn: ERROR
+      priorityFilter:
+        - '1'
+        - '2'
+```
+
+## Kyma CI/CD
+
+### Terraform Integration
+
+```hcl
+# main.tf for Kyma provisioning
+module "kyma" {
+  source = "github.com/SAP/terraform-module-kyma"
+
+  subaccount_id = var.subaccount_id
+  cluster_name  = "my-kyma-cluster"
+  region        = "eu-central-1"
+}
+```
+
+### Helm Deployment
+
+```yaml
+stages:
+  Build:
+    containerBuild: true
+    dockerfilePath: Dockerfile
+
+  Deploy:
+    helmDeploy: true
+    helmValues:
+      - ./chart/values.yaml
+    kubeConfigPath: ${KUBECONFIG}
+```
+
+## Security in CI/CD
+
+### Code Scanning
+
+```yaml
+stages:
+  Security:
+    sonarQubeScan: true
+    sonarQubeConfig:
+      serverUrl: ${SONAR_URL}
+      projectKey: my-project
+
+    dependencyTrackUpload: true
+    fortifyScan: true
+```
+
+### Secrets Management
+
+```yaml
+# Using credentials
+credentials:
+  - name: cf-credentials
+    type: usernamePassword
+    username: ${CF_USER}
+    password: ${CF_PASSWORD}
+
+  - name: hana-credentials
+    type: usernamePassword
+    username: ${HANA_USER}
+    password: ${HANA_PASSWORD}
+```
+
+## Best Practices
+
+### Pipeline Design
+1. Keep pipelines fast (< 15 minutes ideal)
+2. Fail fast on critical issues
+3. Use parallel stages where possible
+4. Cache dependencies
+
+### Testing Strategy
+```yaml
+stages:
+  Unit Tests:
+    # Fast, run on every commit
+    npmScripts: ['test:unit']
+
+  Integration Tests:
+    # Slower, run on PR merge
+    npmScripts: ['test:integration']
+
+  E2E Tests:
+    # Slowest, run before release
+    npmScripts: ['test:e2e']
+```
+
+### Environment Strategy
+
+| Environment | Trigger | Purpose |
+|-------------|---------|---------|
+| Development | Every push | Developer testing |
+| QA | PR merge | QA testing |
+| Staging | Release branch | Pre-production |
+| Production | Manual approval | Live system |
+
+## Monitoring
+
+### Job Status
+- View in CI/CD service UI
+- Email notifications
+- Webhook integrations
+
+### Metrics
+- Build duration
+- Success rate
+- Test coverage
+- Deployment frequency
+
+## Troubleshooting
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Build timeout | Long-running tests | Increase timeout, parallelize |
+| Authentication failed | Expired credentials | Refresh tokens |
+| Deployment failed | Resource quota | Check CF/Kyma limits |
+| Test failures | Environment mismatch | Use consistent test data |
+
+## Learning Resources
+
+| Resource | Description |
+|----------|-------------|
+| "Exploring DevOps with SAP BTP" | SAP Learning course |
+| "Efficient DevOps with SAP" | openSAP course |
+| CI/CD Introduction Guide | Technical documentation |
+
+## Source Documentation
+
+- CI/CD Overview: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/continuous-integration-and-delivery-ci-cd-fe74df5.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/continuous-integration-and-delivery-ci-cd-fe74df5.md)
+- CI/CD Introduction: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/introducing-continuous-integration-and-delivery-ci-cd-8ee5353.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/introducing-continuous-integration-and-delivery-ci-cd-8ee5353.md)
+- SAP CI/CD Service: [https://help.sap.com/docs/continuous-integration-and-delivery](https://help.sap.com/docs/continuous-integration-and-delivery)

references/connectivity.md

@@ -0,0 +1,297 @@
+# SAP BTP Connectivity Reference
+
+## Overview
+
+SAP BTP provides comprehensive connectivity infrastructure for secure communication between cloud applications and various system types including on-premise systems, private clouds, and public cloud services.
+
+## Core Components
+
+### SAP Connectivity Service
+
+**Purpose**: Secure connections to on-premise and private cloud systems
+
+**Features:**
+- Cloud Connector integration
+- Connectivity Proxy support
+- Multiple protocol support
+
+### Cloud Connector
+
+**Purpose**: Secure link between cloud and on-premise systems
+
+**Characteristics:**
+- Operates as reverse proxy in secured networks
+- Controlled resource access
+- No inbound firewall rules required
+- High availability configuration supported
+
+**Installation:**
+- Windows or Linux
+- Portable version available
+- Master-shadow configuration for HA
+
+### Connectivity Proxy
+
+**Purpose**: Cloud-side counterpart to Cloud Connector
+
+**Supported Environments:**
+- Cloud Foundry
+- Kyma
+- Native Kubernetes
+- ABAP Environment
+
+### SAP Destination Service
+
+**Purpose**: Routing and authentication management
+
+**Capabilities:**
+- Store connection properties
+- Manage OAuth token flows
+- Custom parameter handling
+- Design-time configuration
+
+**Destination Types:**
+| Type | Use Case |
+|------|----------|
+| HTTP | REST/OData APIs |
+| RFC | SAP function calls |
+| LDAP | Directory services |
+| Mail | Email servers |
+
+### SAP Transparent Proxy
+
+**Purpose**: Simplify Kubernetes connectivity
+
+**Features:**
+- Exposes target systems on local network
+- Automates authentication
+- Automatic destination retrieval
+- Native Kubernetes integration
+
+## Connectivity Patterns
+
+### Cloud-to-Cloud
+
+**Use Cases:**
+- Kubernetes to databases
+- Application to SAP services
+- OData endpoint consumption
+- Third-party API integration
+
+**Implementation:**
+```yaml
+# destination configuration
+- name: S4HANA_CLOUD
+  type: HTTP
+  url: [https://my-s4.cloud.sap](https://my-s4.cloud.sap)
+  authentication: OAuth2SAMLBearerAssertion
+  tokenServiceURL: [https://my-s4.cloud.sap/sap/bc/sec/oauth2/token](https://my-s4.cloud.sap/sap/bc/sec/oauth2/token)
+```
+
+### Cloud-to-On-Premise
+
+**Supported Systems:**
+- ABAP systems (RFC, OData)
+- Databases
+- Mail servers
+- FTP servers
+- LDAP directories
+
+**User Propagation:**
+- Principal propagation supported
+- SSO via SAML/OAuth
+- Technical user fallback
+
+**Configuration Steps:**
+1. Install Cloud Connector
+2. Connect to BTP subaccount
+3. Map virtual hosts to internal systems
+4. Configure destinations in BTP Cockpit
+
+### On-Premise-to-Cloud
+
+**Use Cases:**
+- RFC callbacks from cloud
+- Kubernetes cluster service access
+- Event notifications
+
+## Destination Configuration
+
+### HTTP Destination (CAP)
+```javascript
+// package.json
+{
+  "cds": {
+    "requires": {
+      "API_BUSINESS_PARTNER": {
+        "kind": "odata-v2",
+        "model": "srv/external/API_BUSINESS_PARTNER",
+        "credentials": {
+          "destination": "S4HANA",
+          "path": "/sap/opu/odata/sap/API_BUSINESS_PARTNER"
+        }
+      }
+    }
+  }
+}
+```
+
+### Destination in BTP Cockpit
+
+| Property | Value | Description |
+|----------|-------|-------------|
+| Name | S4HANA | Destination identifier |
+| Type | HTTP | Protocol type |
+| URL | [https://...](https://...) | Target system URL |
+| Proxy Type | Internet/OnPremise | Connection type |
+| Authentication | OAuth2SAMLBearerAssertion | Auth method |
+
+### Authentication Types
+
+| Type | Use Case |
+|------|----------|
+| NoAuthentication | Public APIs |
+| BasicAuthentication | Technical users |
+| OAuth2ClientCredentials | Server-to-server |
+| OAuth2SAMLBearerAssertion | User propagation |
+| OAuth2UserTokenExchange | Token exchange |
+| PrincipalPropagation | SSO on-premise |
+| ClientCertificateAuthentication | mTLS |
+
+## Cloud Connector Configuration
+
+### System Mapping
+
+```
+Cloud Configuration:
+  Virtual Host: s4hana.cloud
+  Virtual Port: 443
+
+On-Premise Configuration:
+  Internal Host: s4hana.internal.corp
+  Internal Port: 44300
+  Protocol: HTTPS
+```
+
+### Access Control
+
+- Define allowed resources
+- Path-based filtering
+- HTTP method restrictions
+
+### High Availability
+
+1. Install secondary Cloud Connector
+2. Configure as shadow instance
+3. Automatic failover
+
+## CAP Integration
+
+### Remote Service Configuration
+```cds
+// srv/external/API_BUSINESS_PARTNER.cds
+using { API_BUSINESS_PARTNER as external } from './API_BUSINESS_PARTNER';
+
+service RemoteService {
+  entity BusinessPartners as projection on external.A_BusinessPartner {
+    BusinessPartner,
+    BusinessPartnerFullName,
+    BusinessPartnerType
+  };
+}
+```
+
+### Service Implementation
+```javascript
+const cds = require('@sap/cds');
+
+module.exports = cds.service.impl(async function() {
+  const bupa = await cds.connect.to('API_BUSINESS_PARTNER');
+
+  this.on('READ', 'BusinessPartners', async (req) => {
+    return bupa.run(req.query);
+  });
+});
+```
+
+## ABAP Integration
+
+### Communication Arrangement
+
+1. Create Communication System
+2. Define Communication Arrangement
+3. Configure Authentication
+4. Test Connection
+
+### Service Consumption Model
+
+```abap
+" Generated proxy class usage
+DATA(lo_client) = NEW /sap/bc/bupa/a_businesspartner( ).
+
+TRY.
+    DATA(lt_partners) = lo_client->get_business_partners(
+      iv_top = 100
+    ).
+  CATCH cx_remote_call_error INTO DATA(lx_error).
+    " Handle error
+ENDTRY.
+```
+
+### RFC Destination (SM59 equivalent)
+- Configure in Communication Systems app
+- Support for trusted RFC
+- User propagation options
+
+## Kyma Connectivity
+
+### Transparent Proxy Deployment
+```yaml
+apiVersion: gateway.kyma-project.io/v1beta1
+kind: APIRule
+metadata:
+  name: my-api
+spec:
+  gateway: kyma-gateway.kyma-system.svc.cluster.local
+  host: my-api
+  rules:
+    - path: /.*
+      methods: ["GET", "POST"]
+      accessStrategies:
+        - handler: jwt
+```
+
+### Destination Binding
+```yaml
+apiVersion: services.cloud.sap.com/v1
+kind: ServiceBinding
+metadata:
+  name: destination-binding
+spec:
+  serviceInstanceName: destination-instance
+  secretName: destination-secret
+```
+
+## Best Practices
+
+1. **Use Transparent Proxy** for Kubernetes connectivity
+2. **Design-time configuration** via Destination Service
+3. **Connectivity Service** for hybrid cloud-to-on-premise
+4. **Principal propagation** when user context needed
+5. **Technical users** for batch/background processing
+6. **High availability** Cloud Connector for production
+
+## Troubleshooting
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Connection timeout | Firewall blocking | Check Cloud Connector logs |
+| Authentication failed | Token expired | Refresh OAuth configuration |
+| Destination not found | Wrong name | Verify destination exists in subaccount |
+| Certificate error | Untrusted CA | Import certificate in Cloud Connector |
+
+## Source Documentation
+
+- Connecting to Remote Systems: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/connecting-to-remote-systems-d61a5fc.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/connecting-to-remote-systems-d61a5fc.md)
+- SAP Connectivity Service: [https://help.sap.com/docs/connectivity](https://help.sap.com/docs/connectivity)
+- Cloud Connector: [https://help.sap.com/docs/connectivity/sap-btp-connectivity-cf/cloud-connector](https://help.sap.com/docs/connectivity/sap-btp-connectivity-cf/cloud-connector)

references/deployment.md

@@ -0,0 +1,480 @@
+# SAP BTP Deployment Reference
+
+## Overview
+
+SAP BTP supports multiple deployment approaches depending on the runtime (Cloud Foundry, Kyma, or ABAP Environment) and application architecture.
+
+## Cloud Foundry Deployment
+
+### Multitarget Application (MTA)
+
+**Recommended for**: Complex applications with multiple modules and services
+
+#### Build and Deploy
+
+```bash
+# Install MTA Build Tool
+npm install -g mbt
+
+# Build MTA archive
+mbt build
+
+# Deploy to Cloud Foundry
+cf deploy mta_archives/my-app_1.0.0.mtar
+```
+
+#### mta.yaml Structure
+
+```yaml
+_schema-version: "3.1"
+ID: my-cap-app
+version: 1.0.0
+
+parameters:
+  enable-parallel-deployments: true
+
+modules:
+  # Backend service
+  - name: my-srv
+    type: nodejs
+    path: gen/srv
+    parameters:
+      buildpack: nodejs_buildpack
+      memory: 256M
+    requires:
+      - name: my-hana
+      - name: my-xsuaa
+      - name: my-destination
+    provides:
+      - name: srv-api
+        properties:
+          srv-url: ${default-url}
+
+  # UI application
+  - name: my-app
+    type: approuter.nodejs
+    path: app/
+    parameters:
+      memory: 256M
+    requires:
+      - name: srv-api
+        group: destinations
+        properties:
+          name: srv-api
+          url: ~{srv-url}
+          forwardAuthToken: true
+      - name: my-xsuaa
+      - name: my-html5-repo-runtime
+
+  # Database deployer
+  - name: my-db-deployer
+    type: hdb
+    path: gen/db
+    parameters:
+      buildpack: nodejs_buildpack
+    requires:
+      - name: my-hana
+
+resources:
+  - name: my-hana
+    type: com.sap.xs.hdi-container
+    parameters:
+      service: hana
+      service-plan: hdi-shared
+
+  - name: my-xsuaa
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      service-plan: application
+      path: ./xs-security.json
+
+  - name: my-destination
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: destination
+      service-plan: lite
+
+  - name: my-html5-repo-runtime
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: html5-apps-repo
+      service-plan: app-runtime
+```
+
+### Simple cf push
+
+**For**: Simple applications without complex dependencies
+
+```bash
+# Deploy single application
+cf push my-app -p ./dist -m 256M -b nodejs_buildpack
+```
+
+### manifest.yml
+
+```yaml
+applications:
+  - name: my-app
+    memory: 256M
+    instances: 1
+    buildpack: nodejs_buildpack
+    path: ./dist
+    routes:
+      - route: my-app.cfapps.eu10.hana.ondemand.com
+    services:
+      - my-xsuaa
+      - my-destination
+    env:
+      NODE_ENV: production
+```
+
+## Kyma Deployment
+
+### Helm Charts
+
+```bash
+# Add Helm support to CAP
+cds add helm
+
+# Deploy to Kyma
+helm upgrade --install my-app ./chart \
+  --namespace my-namespace \
+  --set image.repository=my-registry/my-app \
+  --set image.tag=1.0.0
+```
+
+### Helm Chart Structure
+
+```
+chart/
+├── Chart.yaml
+├── values.yaml
+└── templates/
+    ├── deployment.yaml
+    ├── service.yaml
+    ├── hpa.yaml
+    └── servicebinding.yaml
+```
+
+### values.yaml
+
+```yaml
+replicaCount: 2
+
+image:
+  repository: my-registry/my-app
+  tag: "1.0.0"
+  pullPolicy: IfNotPresent
+
+service:
+  type: ClusterIP
+  port: 8080
+
+resources:
+  limits:
+    cpu: 500m
+    memory: 512Mi
+  requests:
+    cpu: 100m
+    memory: 256Mi
+
+autoscaling:
+  enabled: true
+  minReplicas: 2
+  maxReplicas: 10
+  targetCPUUtilization: 80
+
+serviceBindings:
+  hana:
+    serviceInstanceName: my-hana
+  xsuaa:
+    serviceInstanceName: my-xsuaa
+```
+
+### Terraform for Kyma
+
+**Purpose**: Automate Kyma cluster provisioning via CI/CD pipelines for resource creation, deployment, testing, and teardown.
+
+**Key Resources:**
+- **Terraform Provider for SAP BTP**: `SAP/btp` - Official SAP-maintained provider ([Terraform Registry](https://registry.terraform.io/providers/SAP/btp/latest/docs))
+- **Kyma Terraform Module**: `github.com/kyma-project/terraform-module` - Open-source module maintained by the Kyma project (SAP-backed)
+
+> **Note**: The Kyma Terraform module is an open-source project. Verify version compatibility and review the module documentation before production use.
+
+#### Prerequisites
+
+1. Terraform CLI on CI worker agents
+2. Admin access (subaccount or global account level)
+3. Dedicated Identity Authentication tenant
+4. Technical user account
+
+#### Variables File (.tfvars)
+
+```hcl
+# .tfvars - Store securely, use credential management
+BTP_BOT_USER              = "technical-user@example.com"
+BTP_BOT_PASSWORD          = "***"
+BTP_GLOBAL_ACCOUNT        = "global-account-subdomain"
+BTP_BACKEND_URL           = "[https://cpcli.cf.sap.hana.ondemand.com"](https://cpcli.cf.sap.hana.ondemand.com")
+BTP_CUSTOM_IAS_TENANT     = "custom-ias-tenant"
+BTP_NEW_SUBACCOUNT_NAME   = "my-subaccount"
+BTP_NEW_SUBACCOUNT_REGION = "eu10"
+BTP_KYMA_PLAN             = "azure"
+BTP_KYMA_REGION           = "westeurope"
+```
+
+#### main.tf Configuration
+
+```hcl
+# main.tf
+terraform {
+  required_providers {
+    btp = {
+      source = "SAP/btp"
+    }
+  }
+}
+
+provider "btp" {
+  globalaccount = var.globalaccount
+}
+
+# Create Kyma environment using official module
+module "kyma" {
+  source = "git::[https://github.com/kyma-project/terraform-module.git?ref=v0.3.1"](https://github.com/kyma-project/terraform-module.git?ref=v0.3.1")
+
+  subaccount_id = var.subaccount_id
+  cluster_name  = var.BTP_NEW_SUBACCOUNT_NAME
+  region        = var.BTP_KYMA_REGION
+
+  administrators = [
+    "admin@example.com"
+  ]
+}
+
+# Outputs
+output "kubeconfig" {
+  value     = module.kyma.kubeconfig
+  sensitive = true
+}
+
+output "cluster_id" {
+  value = module.kyma.cluster_id
+}
+
+output "domain" {
+  value = module.kyma.domain
+}
+```
+
+#### Execution Commands
+
+```bash
+# Initialize Terraform
+terraform init
+
+# Apply configuration
+terraform apply -var-file=.tfvars -auto-approve
+
+# Retrieve outputs
+terraform output -raw cluster_id
+
+# Destroy resources when done
+terraform destroy -var-file=.tfvars -auto-approve
+```
+
+**Security Recommendation**: Use credential management systems (e.g., HashiCorp Vault) for sensitive variables
+
+## ABAP Deployment
+
+### Software Components (gCTS)
+
+**Manage Software Components App:**
+
+1. Create software component
+2. Clone to development system
+3. Develop and release transport requests
+4. Pull to test/production systems
+
+```
+Development Flow:
+[Dev System] → Release TR → [Git Repository] → Pull → [Test System] → Pull → [Prod System]
+```
+
+### Partner Deployment
+
+#### Multitenant SaaS
+
+```
+Partner Global Account:
+├── Provider Subaccount
+│   ├── ABAP System (Development)
+│   ├── ABAP System (Test)
+│   └── ABAP System (Production)
+│       └── Tenant 1
+│       └── Tenant 2
+│       └── Tenant N
+```
+
+**Subscription Process:**
+1. Customer subscribes via SaaS Provisioning
+2. Tenant automatically created
+3. Customer receives access URL
+
+#### Add-on Product
+
+```
+Partner Global Account:
+├── Development Subaccount
+│   └── ABAP System (Dev)
+├── Test Subaccount
+│   └── ABAP System (Test)
+└── Assembly Subaccount
+    └── ABAP System (Assembly)
+
+Customer Global Account:
+└── Production Subaccount
+    └── ABAP System + Add-on
+```
+
+**Delivery via Landscape Portal:**
+1. Build add-on product
+2. Register in SAP Store
+3. Customer installs via Landscape Portal
+
+### abapGit (Migration)
+
+**Use Cases:**
+- On-premise to cloud migration
+- System decommissioning
+- Cross-account transfers
+
+**Not recommended for**: Standard production transports
+
+## SAP Cloud Transport Management
+
+### Configuration
+
+```yaml
+# Integration with CI/CD
+transport:
+  enabled: true
+  landscape:
+    - name: DEV
+      type: Cloud Foundry
+    - name: QA
+      type: Cloud Foundry
+      requires: DEV
+    - name: PROD
+      type: Cloud Foundry
+      requires: QA
+```
+
+### Transport Routes
+
+```
+DEV → QA → PROD
+     ↓
+  [Manual Approval]
+```
+
+## Deployment Best Practices
+
+### Blue-Green Deployment
+
+```bash
+# Deploy new version
+cf push my-app-blue
+
+# Test blue deployment
+# ...
+
+# Switch routes
+cf map-route my-app-blue cfapps.eu10.hana.ondemand.com --hostname my-app
+cf unmap-route my-app-green cfapps.eu10.hana.ondemand.com --hostname my-app
+```
+
+### Rolling Updates (Kyma)
+
+```yaml
+# deployment.yaml
+spec:
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxSurge: 1
+      maxUnavailable: 0
+```
+
+### Environment Variables
+
+```yaml
+# mta.yaml
+modules:
+  - name: my-srv
+    properties:
+      NODE_ENV: production
+      LOG_LEVEL: info
+      # Don't hardcode secrets!
+```
+
+### Resource Sizing
+
+| Environment | Memory | Instances |
+|-------------|--------|-----------|
+| Development | 256M | 1 |
+| QA | 512M | 2 |
+| Production | 1G | 3+ |
+
+## Common Issues
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Memory exceeded | Insufficient allocation | Increase memory in mta.yaml |
+| Service binding failed | Service not created | Create service first |
+| Route conflict | Route already exists | Use unique hostname |
+| Build failed | Missing dependencies | Check package.json |
+
+## Useful Commands
+
+### Cloud Foundry
+
+```bash
+# View logs
+cf logs my-app --recent
+
+# Scale application
+cf scale my-app -i 3 -m 512M
+
+# Restart application
+cf restart my-app
+
+# View environment
+cf env my-app
+
+# Bind service
+cf bind-service my-app my-service
+```
+
+### Kyma/Kubernetes
+
+```bash
+# View pods
+kubectl get pods -n my-namespace
+
+# View logs
+kubectl logs -f deployment/my-app -n my-namespace
+
+# Scale deployment
+kubectl scale deployment my-app --replicas=3 -n my-namespace
+
+# Describe pod
+kubectl describe pod my-app-xxx -n my-namespace
+```
+
+## Source Documentation
+
+- Deploy (ABAP): [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/deploy-d7aec3c.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/deploy-d7aec3c.md)
+- Terraforming Kyma: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/terraforming-kyma-runtimes-57c82ab.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/terraforming-kyma-runtimes-57c82ab.md)
+- MTA Documentation: [https://help.sap.com/docs/btp/sap-business-technology-platform/multitarget-applications-in-cloud-foundry-environment](https://help.sap.com/docs/btp/sap-business-technology-platform/multitarget-applications-in-cloud-foundry-environment)

references/design-patterns.md

@@ -0,0 +1,331 @@
+# SAP BTP Design Patterns Reference
+
+## Overview
+
+Design patterns provide guidance for creating superior user experiences, implementing secure architectures, and building well-modularized applications on SAP BTP.
+
+## User Experience Design
+
+### Core Principle
+
+Superior UX drives business value through:
+- Improved productivity
+- Better data quality
+- Higher user adoption
+
+### Common Challenges
+
+| Challenge | Impact |
+|-----------|--------|
+| Information discovery | Users can't find data |
+| Data fragmentation | Multiple systems to check |
+| Excessive navigation | Wasted time |
+| Poor error handling | User frustration |
+
+### Design Thinking
+
+**Approach**: Understand user needs through observation and feedback
+
+**Process:**
+1. Empathize - Understand users
+2. Define - Clarify problems
+3. Ideate - Generate solutions
+4. Prototype - Build quickly
+5. Test - Validate with users
+
+**Motto**: "Fail fast, fail early"
+
+## Development Use Case Patterns
+
+### Process Automation
+
+**Type**: Low-code/no-code
+
+**Tool**: SAP Build Process Automation
+
+**Best For**: Business experts creating workflows
+
+### Web and Mobile Applications
+
+**Tool**: SAP Build Apps, MDK
+
+**Best For**: Cross-platform consumer applications
+
+### Full-Stack Development
+
+**Types:**
+- Single-tenant applications
+- Multitenant SaaS applications
+- Tenant-specific extensions
+
+**Reference Apps:**
+- Poetry Slam Manager (SaaS)
+- Catering Management (Extension)
+- Incident Management (Full-stack)
+
+## Technology Design
+
+### Modularization Benefits
+
+| Benefit | Description |
+|---------|-------------|
+| Maintainability | Easier to understand and modify |
+| Testability | Independent unit testing |
+| Scalability | Scale individual components |
+| Reduced coupling | Changes don't cascade |
+| Faster innovation | Independent development |
+
+### Domain-Driven Design (DDD)
+
+**When to Use**: Applications with 30+ use cases, complex domains
+
+**Recommended Approach (SAP BTP/CAP):**
+1. **SAP One Domain Model**: Leverage SAP's standardized business data model for consistency across SAP solutions
+2. **CAP Domain Modeling**: Use CDS for human-readable, business-aligned domain models
+3. **Community Practices**: Apply EventStorming, bounded-context discovery for complex scenarios
+
+**Complexity Scoring Heuristic**:
+
+> **Note**: This scoring is a pragmatic heuristic to help decide when deeper DDD practices (EventStorming, bounded-context discovery) may provide value. Always validate triggers against domain expert input, non-functional requirements (performance, scalability), and team constraints before applying.
+
+| Criterion | Points | Consideration |
+|-----------|--------|---------------|
+| 30+ use cases | 2 | Scale indicator |
+| Anticipated growth | 1 | Future complexity |
+| Significant future changes | 2 | Maintainability needs |
+| Novel domain | 2 | Unknown complexity |
+
+**Score 7+ points**: Consider deeper DDD practices
+
+**DDD Process** (8 steps from ddd-crew):
+1. Align business goals
+2. Discover domain
+3. Decompose domain
+4. Connect bounded contexts
+5. Strategize models
+6. Define domain events
+7. Design bounded contexts
+8. Evolve architecture
+
+**Resources:**
+- SAP One Domain Model: [https://api.sap.com/sap-one-domain-model](https://api.sap.com/sap-one-domain-model)
+- CAP Domain Modeling: [https://cap.cloud.sap/docs/guides/domain-modeling](https://cap.cloud.sap/docs/guides/domain-modeling)
+- DDD Starter Modeling: [https://github.com/ddd-crew/ddd-starter-modelling-process](https://github.com/ddd-crew/ddd-starter-modelling-process)
+
+## CAP Design Principles
+
+### Domain-Driven Development
+
+- Collaborate with domain experts
+- Use CDS for human-readable models
+- Focus on business concepts
+
+### Out-of-the-Box Best Practices
+
+CAP provides automatic:
+- OData service generation
+- CRUD operations
+- Authorization checks
+- Audit logging
+
+### Platform Agnostic Design
+
+CAP abstracts:
+- Deployment targets (CF, Kyma)
+- Authentication methods
+- Protocols (REST, OData, GraphQL)
+- Database technologies
+- Messaging systems
+
+## ABAP Design Principles
+
+### Model-Driven Architecture
+
+**Benefits:**
+- Common architecture reduces boilerplate
+- Patterns transfer across implementations
+- Built-in mock frameworks
+- Consistent code quality
+
+### Use Case Patterns
+
+**Customer Applications:**
+- Decoupled lifecycles
+- Independent workload management
+- Hub scenarios
+
+**Partner Solutions:**
+- Multitenant SaaS
+- Add-on products
+
+**Other:**
+- Mobile applications
+- Business automation
+- Code quality analysis
+
+## Security Design
+
+### Five Guidelines
+
+| Guideline | Focus |
+|-----------|-------|
+| Secure User Interfaces | SAP Fiori authentication, validation |
+| Access Control Models | RBAC/ABAC with OAuth/OpenID Connect |
+| API Security | OAuth 2.0, TLS encryption |
+| Secure Extensibility | Isolate and validate custom logic |
+| Domain Model Validation | Review CDS models for data protection |
+
+### Secure SDLC
+
+**Explore Phase:**
+- Implement OWASP standards
+- Train development teams
+- Conduct risk assessments
+- Plan compliance requirements
+
+**Discover Phase:**
+- Map data flows
+- Establish secure architecture
+- Validate third-party services
+- Incorporate security in prototypes
+
+**Design Phase:**
+- Apply least privilege
+- Implement defense in depth
+- Validate inputs at boundaries
+
+## Microservices Patterns
+
+### When to Use
+
+**Benefits:**
+- Independent scaling
+- Technology flexibility
+- Team autonomy
+
+**Considerations:**
+- Increased complexity
+- Network latency
+- Distributed transactions
+
+### CAP Approach
+
+Start monolithic, extract services when:
+- Different scaling needs
+- Different team ownership
+- Independent deployment required
+
+### Communication Patterns
+
+| Pattern | Use Case |
+|---------|----------|
+| Synchronous (REST/OData) | Real-time queries |
+| Asynchronous (Events) | Decoupled processes |
+| Event Sourcing | Audit requirements |
+
+## Database Design
+
+### CAP with CDS
+
+```cds
+// Domain model
+entity Orders {
+  key ID : UUID;
+  customer : Association to Customers;
+  items : Composition of many OrderItems on items.order = $self;
+  status : Status;
+}
+
+entity OrderItems {
+  key ID : UUID;
+  order : Association to Orders;
+  product : Association to Products;
+  quantity : Integer;
+}
+```
+
+### ABAP with CDS
+
+```abap
+define root view entity ZI_Order
+  as select from zorder
+  composition [0..*] of ZI_OrderItem as _Items
+{
+  key order_uuid as OrderUUID,
+      customer_id as CustomerID,
+      _Items
+}
+```
+
+## API Design
+
+### API-First Approach
+
+1. Design API before implementation
+2. Use OpenAPI/OData specifications
+3. Follow SAP API Style Guide
+4. Publish to API Business Hub
+
+### Versioning Strategy
+
+```
+/api/v1/orders    # Version 1
+/api/v2/orders    # Version 2 (breaking changes)
+```
+
+## Testing Patterns
+
+### Test Pyramid
+
+```
+        /\
+       /  \      E2E Tests (few)
+      /----\
+     /      \    Integration Tests (some)
+    /--------\
+   /          \  Unit Tests (many)
+  /------------\
+```
+
+### CAP Testing
+
+```javascript
+const cds = require('@sap/cds');
+
+describe('OrderService', () => {
+  let srv;
+
+  beforeAll(async () => {
+    srv = await cds.connect.to('OrderService');
+  });
+
+  it('creates order', async () => {
+    const order = await srv.create('Orders', {
+      customerID: '123'
+    });
+    expect(order.ID).toBeDefined();
+  });
+});
+```
+
+### ABAP Testing
+
+```abap
+CLASS ltcl_order DEFINITION FOR TESTING.
+  METHODS test_create_order FOR TESTING.
+ENDCLASS.
+
+CLASS ltcl_order IMPLEMENTATION.
+  METHOD test_create_order.
+    " Test implementation
+    cl_abap_unit_assert=>assert_not_initial( lv_order_id ).
+  ENDMETHOD.
+ENDCLASS.
+```
+
+## Source Documentation
+
+- Design (CAP): [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/design-6bb7339.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/design-6bb7339.md)
+- Design (ABAP): [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/design-314ae3e.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/design-314ae3e.md)
+- Technology Design: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/technology-design-a5b8129.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/technology-design-a5b8129.md)
+- UX Design: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/user-experience-design-323bd93.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/user-experience-design-323bd93.md)

references/extensions.md

@@ -0,0 +1,267 @@
+# SAP Solution Extensions Reference
+
+## Overview
+
+SAP BTP enables organizations to extend existing SAP solutions without disrupting core performance and business processes. Extensions can add new functionality while maintaining upgrade compatibility.
+
+## Extension Types
+
+### In-App Extensions
+
+**Definition**: Extend backend and UI directly within the SAP solution
+
+**Supported Products:**
+- SAP SuccessFactors
+- SAP S/4HANA Cloud
+- SAP Cloud for Customer
+
+**Capabilities:**
+- Custom fields
+- Custom logic (BAdIs)
+- UI adaptations
+- Custom reports
+
+### Side-by-Side Extensions
+
+**Definition**: Additional functionality deployed on SAP BTP, integrated with SAP solutions
+
+**Advantages:**
+
+| Area | Benefit |
+|------|---------|
+| Business | Independent feature development |
+| Technology | Modern cloud-native architecture |
+| Operations | Separate lifecycle management |
+
+## Planning Recommendations
+
+1. **Start simple** - Begin with straightforward implementations
+2. **Maintain focused digital core** - Keep core system clean
+3. **Choose simplest approach** - Don't over-engineer
+4. **Verify API/event availability** - Ensure integration points exist
+
+## Supported SAP Solutions
+
+### Solutions with Automated Configuration
+
+| Solution | Extension Service |
+|----------|------------------|
+| SAP S/4HANA Cloud | SAP S/4HANA Cloud Extensibility |
+| SAP SuccessFactors | SAP SuccessFactors Extensibility |
+| SAP Cloud for Customer | Standard extensibility service |
+| SAP Commerce Cloud | Commerce Cloud extensibility |
+| SAP Field Service Management | FSM extensibility |
+
+## Extension Use Cases
+
+### UI Enhancement
+
+**Scenario**: Build new SAP Fiori interfaces integrated with SAP solutions
+
+**Implementation:**
+```javascript
+// CAP service consuming S/4HANA API
+const cds = require('@sap/cds');
+
+module.exports = (srv) => {
+  srv.on('READ', 'BusinessPartners', async (req) => {
+    const s4 = await cds.connect.to('API_BUSINESS_PARTNER');
+    return s4.run(req.query);
+  });
+};
+```
+
+### Functionality Expansion
+
+**Scenario**: Connect multiple SAP solutions
+
+**Example**: Link SAP SuccessFactors employee data with SAP S/4HANA
+
+### Advanced Capabilities
+
+**Scenarios:**
+- Add analytics dashboards
+- Implement machine learning
+- Enable IoT integration
+
+### Data Consolidation
+
+**Scenario**: Centralize insights across systems
+
+**Tools:**
+- SAP Datasphere
+- SAP Analytics Cloud
+- Custom CAP aggregators
+
+### SaaS Ecosystems
+
+**Scenario**: Create multi-tenant extension applications for distribution
+
+**Considerations:**
+- Subscription management
+- Tenant isolation
+- Key user extensibility
+
+## Implementation Patterns
+
+### Remote Service Integration (CAP)
+
+#### Step 1: Import Service Definition
+
+```bash
+# Download API specification
+cds import API_BUSINESS_PARTNER.edmx
+```
+
+#### Step 2: Configure Connection
+
+```json
+// package.json
+{
+  "cds": {
+    "requires": {
+      "API_BUSINESS_PARTNER": {
+        "kind": "odata-v2",
+        "model": "srv/external/API_BUSINESS_PARTNER",
+        "credentials": {
+          "destination": "S4HANA"
+        }
+      }
+    }
+  }
+}
+```
+
+#### Step 3: Implement Service
+
+```javascript
+// srv/extension-service.js
+const cds = require('@sap/cds');
+
+module.exports = cds.service.impl(async function() {
+  const s4 = await cds.connect.to('API_BUSINESS_PARTNER');
+
+  this.on('READ', 'BusinessPartners', async (req) => {
+    return s4.run(req.query);
+  });
+
+  this.on('CREATE', 'LocalEntities', async (req) => {
+    // Local business logic
+    const data = req.data;
+    // Enrich with S/4HANA data
+    const bp = await s4.read('A_BusinessPartner').where({ BusinessPartner: data.partnerId });
+    data.partnerName = bp[0]?.BusinessPartnerFullName;
+    return data;
+  });
+});
+```
+
+### Event-Based Integration
+
+#### Event Subscription
+
+```cds
+// srv/extension-service.cds
+using { sap.s4.beh } from 'srv/external/OP_API_BUSINESS_PARTNER_SRV';
+
+service ExtensionService {
+  // React to S/4HANA events
+  event BusinessPartnerChanged : {
+    BusinessPartner : String;
+  }
+}
+```
+
+#### Event Handler
+
+```javascript
+// srv/extension-service.js
+module.exports = (srv) => {
+  srv.on('BusinessPartnerChanged', async (msg) => {
+    const { BusinessPartner } = msg.data;
+    console.log(`Business Partner ${BusinessPartner} changed`);
+    // Trigger local business logic
+  });
+};
+```
+
+### Eventing via SAP Event Mesh
+
+```yaml
+# mta.yaml
+resources:
+  - name: my-event-mesh
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: enterprise-messaging
+      service-plan: default
+      config:
+        emname: my-namespace
+```
+
+## ABAP Extensions (On-Stack)
+
+### Developer Extensibility
+
+**Available In**: SAP S/4HANA Cloud, Private Edition
+
+**Capabilities:**
+- Custom CDS views
+- Custom RAP business objects
+- Released API consumption
+
+### Key User Extensibility
+
+**Available In**: Multitenant SaaS applications
+
+**Capabilities:**
+- UI adaptations
+- Custom fields
+- Business Add-Ins (BAdIs)
+- Business configuration
+
+## Best Practices
+
+### Architecture
+
+| Principle | Description |
+|-----------|-------------|
+| Loose coupling | Use APIs/events, not direct DB access |
+| Idempotent operations | Handle duplicate events gracefully |
+| Error handling | Implement retry logic, circuit breakers |
+| Security | Follow least privilege principle |
+
+### Development
+
+1. **Use mock servers** for development without production access
+2. **Test with real data** before production deployment
+3. **Monitor integration health** with SAP Cloud ALM
+4. **Document APIs** for maintainability
+
+### Operations
+
+1. **Separate lifecycles** - Deploy extensions independently
+2. **Version APIs** - Maintain compatibility during upgrades
+3. **Monitor performance** - Track integration latency
+4. **Plan for upgrades** - Test against SAP update schedules
+
+## Resources
+
+| Resource | URL |
+|----------|-----|
+| SAP Extensibility Explorer | [https://experience.sap.com/extensibility-explorer/](https://experience.sap.com/extensibility-explorer/) |
+| Discovery Center Missions | [https://discovery-center.cloud.sap/](https://discovery-center.cloud.sap/) |
+| CAP External Services | [https://cap.cloud.sap/docs/guides/using-services](https://cap.cloud.sap/docs/guides/using-services) |
+
+## Related Skill Guides
+
+| Topic | Reference |
+|-------|-----------|
+| Design Patterns | `references/design-patterns.md` - DDD, modularization |
+| Security | `references/security.md` - Authentication, authorization |
+| Operations | `references/operations.md` - Scaling, monitoring |
+| Connectivity | `references/connectivity.md` - Remote services, destinations |
+
+## Source Documentation
+
+- Extending SAP Solutions: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/extending-existing-sap-solutions-using-sap-btp-40aa232.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/extending-existing-sap-solutions-using-sap-btp-40aa232.md)

references/hana-cloud.md

@@ -0,0 +1,271 @@
+# SAP HANA Cloud Reference
+
+## Overview
+
+SAP HANA Cloud is a cloud-native Database-as-a-Service forming the database management foundation of SAP BTP. It eliminates hardware management overhead and supports multiple data models.
+
+## Supported Data Models
+
+| Model | Use Case |
+|-------|----------|
+| Relational | Traditional OLTP/OLAP |
+| Document | JSON storage |
+| Geospatial | Location data |
+| Vector | AI/ML applications |
+
+## Cost Optimization Features
+
+### Native Storage Extension (NSE)
+
+**Purpose**: Store infrequently accessed data on disk instead of in-memory
+
+**Benefits:**
+- Reduced memory requirements
+- Lower costs for cold data
+- Automatic data tiering
+
+**NSE Advisor**: Provides data-driven suggestions for storage optimization
+
+### Elastic Compute Nodes (ECN)
+
+**Purpose**: On-demand computational scaling during peak workloads
+
+**Features:**
+- Scheduled activation/deactivation
+- Automatic scaling based on metrics
+- ECN Advisors for usage pattern analysis
+
+### Table Partitioning
+
+**Purpose**: Divide large tables for better query performance
+
+**Benefits:**
+- Parallel query processing
+- Partition pruning
+- Works on multi-host and single-host configurations
+
+### Native Multi-Tenancy
+
+**Capability**: Up to 1,000 isolated database tenants per instance
+
+**Use Case**: SaaS applications with tenant data isolation
+
+### Free Tier
+
+**Allocation**: 16GB memory at no cost via BTP
+
+**Benefits:**
+- Development without trial limitations
+- Upgrade path to paid plans
+- Full feature access
+
+## CAP Integration
+
+### CDS-Based Modeling
+
+```cds
+// db/schema.cds
+namespace my.bookshop;
+
+entity Books {
+  key ID : UUID;
+  title  : String(111);
+  stock  : Integer;
+  price  : Decimal(10, 2);
+}
+```
+
+### Automatic Artifact Generation
+
+CAP uses CDS to:
+- Define domain models
+- Generate database artifacts automatically
+- Support local, hybrid, and cloud deployments
+
+### Adding HANA Support
+
+```bash
+# Add HANA to CAP project
+cds add hana
+
+# Build for HANA
+cds build --production
+
+# Deploy database
+cds deploy --to hana
+```
+
+### Service Configuration
+
+```json
+// package.json
+{
+  "cds": {
+    "requires": {
+      "db": {
+        "[production]": {
+          "kind": "hana"
+        },
+        "[development]": {
+          "kind": "sqlite"
+        }
+      }
+    }
+  }
+}
+```
+
+### HDI Container Configuration
+
+```yaml
+# mta.yaml
+resources:
+  - name: my-hana
+    type: com.sap.xs.hdi-container
+    parameters:
+      service: hana
+      service-plan: hdi-shared
+      config:
+        schema: MY_SCHEMA
+```
+
+## ABAP Environment Integration
+
+### Automatic Integration
+
+The SAP BTP ABAP environment automatically includes:
+- Dedicated HANA Cloud instance
+- ABAP-managed database access
+- Native SQL support via ABAP SQL
+
+### Features
+
+| Feature | Description |
+|---------|-------------|
+| Native Storage Extensions | Extended disk storage |
+| Database Indexes | Custom index creation |
+| Partitioning | Table partitioning support |
+| ABAP SQL Service | External access to data |
+
+### CDS Views in ABAP
+
+```abap
+@AbapCatalog.viewEnhancementCategory: [#NONE]
+@AccessControl.authorizationCheck: #NOT_REQUIRED
+@EndUserText.label: 'Sales Order'
+define view entity ZI_SalesOrder
+  as select from zsales_order
+{
+  key order_uuid    as OrderUUID,
+      order_id      as OrderID,
+      customer_id   as CustomerID,
+      @Semantics.amount.currencyCode: 'CurrencyCode'
+      total_amount  as TotalAmount,
+      currency_code as CurrencyCode
+}
+```
+
+## Database Development
+
+### Native SQL in CAP (Node.js)
+
+```javascript
+const cds = require('@sap/cds');
+
+module.exports = (srv) => {
+  srv.on('customQuery', async (req) => {
+    const db = await cds.connect.to('db');
+    const result = await db.run(`
+      SELECT * FROM my_bookshop_Books
+      WHERE stock > 0
+      ORDER BY title
+    `);
+    return result;
+  });
+};
+```
+
+### Stored Procedures
+
+```sql
+-- db/src/procedures/calculateTotal.hdbprocedure
+PROCEDURE "calculateTotal" (
+  IN iv_order_id NVARCHAR(36),
+  OUT ov_total DECIMAL(15,2)
+)
+LANGUAGE SQLSCRIPT
+SQL SECURITY INVOKER
+READS SQL DATA
+AS
+BEGIN
+  SELECT SUM(quantity * price) INTO ov_total
+  FROM "my_bookshop_OrderItems"
+  WHERE order_id = :iv_order_id;
+END;
+```
+
+### Calculation Views
+
+```xml
+<!-- db/src/views/SalesAnalytics.hdbcalculationview -->
+<Calculation:scenario xmlns:xsi="[http://www.w3.org/2001/XMLSchema-instance"](http://www.w3.org/2001/XMLSchema-instance")
+  xmlns:Calculation="[http://www.sap.com/ndb/BiModelCalculation.ecore"](http://www.sap.com/ndb/BiModelCalculation.ecore")
+  id="SalesAnalytics"
+  applyPrivilegeType="NONE">
+  <!-- View definition -->
+</Calculation:scenario>
+```
+
+## Performance Optimization
+
+### Best Practices
+
+| Practice | Description |
+|----------|-------------|
+| Use NSE for cold data | Move infrequently accessed data to disk |
+| Partition large tables | Improve query performance |
+| Create appropriate indexes | Speed up common queries |
+| Use calculation views | Optimize analytical queries |
+| Leverage in-memory | Keep hot data in memory |
+
+### Monitoring
+
+**Tools:**
+- SAP HANA Cockpit
+- Technical Monitoring Cockpit (ABAP)
+- SAP Cloud ALM
+
+**Key Metrics:**
+- Memory utilization
+- CPU usage
+- Query performance
+- Connection pool status
+
+## Backup and Recovery
+
+### Automatic Backups
+- Continuous backup
+- Point-in-time recovery
+- Cross-region backup options
+
+### Recovery Options
+- Self-service restore via HANA Cockpit
+- SAP support for disaster recovery
+
+## Security
+
+### Data Encryption
+- Encryption at rest
+- Encryption in transit (TLS)
+- Column-level encryption options
+
+### Access Control
+- Database users and roles
+- Row-level security via CDS
+- Integration with XSUAA
+
+## Source Documentation
+
+- Data Persistence: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/data-persistence-using-usap-hana-cloud-f19c8e9.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/data-persistence-using-usap-hana-cloud-f19c8e9.md)
+- SAP HANA Cloud: [https://help.sap.com/docs/hana-cloud](https://help.sap.com/docs/hana-cloud)
+- CAP HANA Guide: [https://cap.cloud.sap/docs/guides/databases-hana](https://cap.cloud.sap/docs/guides/databases-hana)

references/mta.md

@@ -0,0 +1,308 @@
+# Multitarget Applications (MTA) Reference
+
+## Overview
+
+Multitarget Applications enable packaging multiple interconnected cloud components into a single deployable bundle, addressing the complexity of modern cloud applications.
+
+## Key Characteristics
+
+- Single archive with all modules and dependencies
+- Deployable across multiple SAP BTP subaccounts
+- Automated deployment in proper dependency order
+- Integrated deployment descriptor (mta.yaml)
+
+## When to Use MTAs
+
+| Scenario | Recommendation |
+|----------|----------------|
+| Business app with multiple components | Use MTA |
+| Dependencies on external resources (DB, messaging) | Use MTA |
+| Need standardized configuration | Use MTA |
+| Simple single-module app | Consider cf push |
+
+## Creation Options
+
+| Tool | Description |
+|------|-------------|
+| SAP Business Application Studio | Native MTA support |
+| SAP Web IDE Full-Stack | Automatic descriptor maintenance |
+| mbt (Command Line) | Java-based builder |
+| CI/CD Pipelines | Automated archive generation |
+
+## MTA Structure
+
+```
+my-app/
+├── mta.yaml              # Deployment descriptor
+├── package.json          # Node.js dependencies
+├── xs-security.json      # Security configuration
+├── app/                  # UI module
+│   ├── webapp/
+│   └── package.json
+├── srv/                  # Service module
+│   ├── src/
+│   └── package.json
+└── db/                   # Database module
+    ├── src/
+    └── package.json
+```
+
+## mta.yaml Anatomy
+
+### Schema and Identification
+
+```yaml
+_schema-version: "3.1"
+ID: my-cap-app
+version: 1.0.0
+description: My CAP Application
+```
+
+### Parameters
+
+```yaml
+parameters:
+  enable-parallel-deployments: true
+  deploy_mode: html5-repo
+```
+
+### Modules
+
+```yaml
+modules:
+  - name: my-srv
+    type: nodejs
+    path: gen/srv
+    parameters:
+      buildpack: nodejs_buildpack
+      memory: 256M
+      disk-quota: 512M
+    build-parameters:
+      builder: npm
+    requires:
+      - name: my-hana
+      - name: my-xsuaa
+    provides:
+      - name: srv-api
+        properties:
+          srv-url: ${default-url}
+```
+
+### Resources
+
+```yaml
+resources:
+  - name: my-hana
+    type: com.sap.xs.hdi-container
+    parameters:
+      service: hana
+      service-plan: hdi-shared
+
+  - name: my-xsuaa
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      service-plan: application
+      path: ./xs-security.json
+```
+
+## Module Types
+
+| Type | Description |
+|------|-------------|
+| nodejs | Node.js application |
+| java | Java application |
+| hdb | HANA database content |
+| html5 | Static HTML5 content |
+| approuter.nodejs | Application Router |
+| com.sap.application.content | Generic content |
+
+## Resource Types
+
+| Type | Description |
+|------|-------------|
+| com.sap.xs.hdi-container | HDI container |
+| org.cloudfoundry.managed-service | Managed service instance |
+| org.cloudfoundry.existing-service | Existing service reference |
+| org.cloudfoundry.user-provided-service | User-provided service |
+
+## Complete Example
+
+```yaml
+_schema-version: "3.1"
+ID: incident-management
+version: 1.0.0
+
+parameters:
+  enable-parallel-deployments: true
+
+build-parameters:
+  before-all:
+    - builder: custom
+      commands:
+        - npm ci
+        - npx cds build --production
+
+modules:
+  # Service module
+  - name: incident-srv
+    type: nodejs
+    path: gen/srv
+    parameters:
+      buildpack: nodejs_buildpack
+      memory: 256M
+    requires:
+      - name: incident-db
+      - name: incident-auth
+      - name: incident-destination
+    provides:
+      - name: srv-api
+        properties:
+          srv-url: ${default-url}
+
+  # Database deployer
+  - name: incident-db-deployer
+    type: hdb
+    path: gen/db
+    parameters:
+      buildpack: nodejs_buildpack
+    requires:
+      - name: incident-db
+
+  # UI Application
+  - name: incident-app
+    type: approuter.nodejs
+    path: app/
+    parameters:
+      memory: 256M
+    requires:
+      - name: srv-api
+        group: destinations
+        properties:
+          name: srv-api
+          url: ~{srv-url}
+          forwardAuthToken: true
+      - name: incident-auth
+      - name: incident-html5-repo-runtime
+
+  # UI content deployer
+  - name: incident-ui-deployer
+    type: com.sap.application.content
+    path: .
+    requires:
+      - name: incident-html5-repo-host
+        parameters:
+          content-target: true
+    build-parameters:
+      build-result: resources
+      requires:
+        - artifacts:
+            - nsincidents.zip
+          name: nsincidents
+          target-path: resources/
+
+  - name: nsincidents
+    type: html5
+    path: app/incidents
+    build-parameters:
+      build-result: dist
+      builder: custom
+      commands:
+        - npm ci
+        - npm run build:cf
+
+resources:
+  - name: incident-db
+    type: com.sap.xs.hdi-container
+    parameters:
+      service: hana
+      service-plan: hdi-shared
+
+  - name: incident-auth
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      service-plan: application
+      path: ./xs-security.json
+      config:
+        xsappname: incident-${org}-${space}
+        tenant-mode: dedicated
+
+  - name: incident-destination
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: destination
+      service-plan: lite
+
+  - name: incident-html5-repo-runtime
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: html5-apps-repo
+      service-plan: app-runtime
+
+  - name: incident-html5-repo-host
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: html5-apps-repo
+      service-plan: app-host
+```
+
+## Build Commands
+
+```bash
+# Install MTA Build Tool
+npm install -g mbt
+
+# Build MTA archive
+mbt build
+
+# Build with specific platform
+mbt build -p cf
+
+# Build to specific directory
+mbt build -t ./dist
+```
+
+## Deploy Commands
+
+```bash
+# Install MTA plugin
+cf install-plugin multiapps
+
+# Deploy
+cf deploy mta_archives/my-app_1.0.0.mtar
+
+# Deploy with options
+cf deploy my-app.mtar --version-rule ALL
+
+# Blue-green deployment
+cf bg-deploy my-app.mtar
+
+# List deployed MTAs
+cf mtas
+
+# Undeploy
+cf undeploy my-app --delete-services
+```
+
+## Common Issues
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Service binding fails | Service not ready | Add dependency order |
+| Memory exceeded | Insufficient allocation | Increase in mta.yaml |
+| Build fails | Missing dependencies | Run npm ci first |
+| Deploy timeout | Large application | Increase timeout |
+
+## Best Practices
+
+1. **Use build-parameters** for complex builds
+2. **Enable parallel deployments** for faster deploys
+3. **Externalize configuration** via variables
+4. **Version your MTAs** semantically
+5. **Test locally** before deploying
+
+## Source Documentation
+
+- Using MTAs: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/using-multitarget-applications-to-manage-dependencies-41184aa.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/using-multitarget-applications-to-manage-dependencies-41184aa.md)
+- MTA Documentation: [https://help.sap.com/docs/btp/sap-business-technology-platform/multitarget-applications-in-cloud-foundry-environment](https://help.sap.com/docs/btp/sap-business-technology-platform/multitarget-applications-in-cloud-foundry-environment)

references/observability.md

@@ -0,0 +1,279 @@
+# SAP BTP Observability Reference
+
+## Overview
+
+SAP BTP observability operates through two interconnected layers:
+- **Central Layer**: SAP Cloud ALM - unified strategic view
+- **Local Layer**: SAP Cloud Logging - granular technical insights
+
+Both layers integrate through APIs and context-sensitive navigation using telemetry data (logs, metrics, traces).
+
+## OpenTelemetry Strategy
+
+SAP has standardized on OpenTelemetry as the industry standard for cloud-native observability.
+
+**Key Principles:**
+- Standardized instrumentation across SAP and customer applications
+- Open APIs for non-SAP data source integration
+- Seamless data flow through managed collectors
+
+## SAP Cloud ALM
+
+**Included with**: Enterprise Support subscriptions
+
+**Provisioning**: Via SAP for Me
+
+### Capabilities
+
+| Feature | Description |
+|---------|-------------|
+| Real User Monitoring | Actual user experience tracking |
+| Health Monitoring | System and application health |
+| Integration Monitoring | Cross-system integration status |
+| Exception Monitoring | Error tracking and analysis |
+| Job Monitoring | Background job status |
+| Automation Monitoring | Automated process tracking |
+| Synthetic User Monitoring | Selenium-based availability tests |
+| Business Service Management | End-to-end service health |
+| Intelligent Event Processing | Automated event correlation |
+
+### Supported Platforms
+
+**SaaS Applications:**
+- SAP S/4HANA Cloud
+- SAP HANA Cloud
+- SAP Analytics Cloud
+
+**PaaS Runtimes:**
+- Cloud Foundry
+- Kyma
+
+### Integration
+
+```yaml
+# CAP configuration for Cloud ALM
+cds:
+  requires:
+    cloud-alm:
+      kind: sap-cloud-alm
+      credentials:
+        destination: cloud-alm-api
+```
+
+## SAP Cloud Logging
+
+**Based on**: OpenSearch
+
+**Deployment**: Instance-based service
+
+### Capabilities
+
+| Feature | Description |
+|---------|-------------|
+| Log Analytics | Full-text search, structured queries |
+| Distributed Tracing | Cross-microservice request tracking |
+| Technology Monitoring | Runtime metrics (Java/Node.js) |
+| Custom Telemetry | Application-specific metrics |
+| Alerting | Threshold-based notifications |
+| Dashboards | Custom visualizations |
+
+### Service Binding
+
+```yaml
+# mta.yaml
+resources:
+  - name: my-cloud-logging
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: cloud-logging
+      service-plan: standard
+
+modules:
+  - name: my-srv
+    requires:
+      - name: my-cloud-logging
+```
+
+### CAP Integration
+
+```javascript
+// Automatic logging with CAP
+const cds = require('@sap/cds');
+const LOG = cds.log('my-service');
+
+module.exports = (srv) => {
+  srv.on('READ', 'Books', (req) => {
+    LOG.info('Reading books', { user: req.user.id });
+    // Business logic
+  });
+};
+```
+
+### Custom Metrics
+
+> **Note**: This snippet assumes a MeterProvider is already configured by the platform (e.g., SAP Cloud Logging SDK) or application bootstrap. When using SAP BTP services, the telemetry infrastructure typically provides this setup automatically.
+
+```javascript
+const { metrics } = require('@opentelemetry/api');
+
+// Assumes MeterProvider is registered by SAP Cloud Logging or platform setup
+const meter = metrics.getMeter('my-app');
+const orderCounter = meter.createCounter('orders_created', {
+  description: 'Number of orders created'
+});
+
+// Increment counter
+orderCounter.add(1, { customer_type: 'enterprise' });
+```
+
+### Custom Traces
+```javascript
+const { trace } = require('@opentelemetry/api');
+
+const tracer = trace.getTracer('my-app');
+
+async function processOrder(orderId) {
+  const span = tracer.startSpan('process-order');
+  span.setAttribute('order.id', orderId);
+
+  try {
+    // Processing logic
+    span.setStatus({ code: SpanStatusCode.OK });
+  } catch (error) {
+    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+    throw error;
+  } finally {
+    span.end();
+  }
+}
+```
+
+## SAP Alert Notification
+
+**Purpose**: Route critical events to notification channels
+
+**Channels:**
+- Email
+- SMS
+- Slack
+- Microsoft Teams
+- ServiceNow
+- Custom webhooks
+
+### Configuration
+```json
+{
+  "conditions": [
+    {
+      "name": "critical-errors",
+      "propertyKey": "severity",
+      "predicate": "EQUALS",
+      "propertyValue": "CRITICAL"
+    }
+  ],
+  "actions": [
+    {
+      "name": "notify-team",
+      "type": "SLACK",
+      "properties": {
+        "webhookUrl": "[https://hooks.slack.com/..."](https://hooks.slack.com/...")
+      }
+    }
+  ]
+}
+```
+
+## ABAP Technical Monitoring Cockpit
+
+**Purpose**: On-stack analysis and optimization
+
+**Features:**
+- System workload monitoring
+- Resource consumption tracking
+- Request statistics
+- Outbound communication analysis
+- SQL statement analysis
+- Work process monitoring
+
+### Key Metrics
+
+| Metric | Description |
+|--------|-------------|
+| Dialog Response Time | Average transaction response |
+| CPU Utilization | Application server CPU usage |
+| Memory Consumption | Heap and stack usage |
+| Database Time | SQL execution duration |
+| Work Process Usage | Active vs. total processes |
+
+## Implementation by Runtime
+
+### Cloud Foundry
+
+```yaml
+# manifest.yml
+applications:
+  - name: my-app
+    env:
+      SAP_CLOUD_LOGGING_ENABLED: true
+      OTEL_EXPORTER_OTLP_ENDPOINT: "..."
+```
+
+### Kyma
+
+```yaml
+apiVersion: telemetry.kyma-project.io/v1alpha1
+kind: LogPipeline
+metadata:
+  name: my-logs
+spec:
+  input:
+    application:
+      namespaces:
+        include: [my-namespace]
+  output:
+    http:
+      host: cloud-logging-endpoint
+```
+
+### ABAP Environment
+
+Automatic integration with:
+- Technical Monitoring Cockpit
+- SAP Cloud ALM
+- Security Audit Log
+- Application Logging
+
+## Best Practices
+
+### Logging
+1. Use structured logging (JSON format)
+2. Include correlation IDs for request tracing
+3. Log at appropriate levels (DEBUG, INFO, WARN, ERROR)
+4. Avoid logging sensitive data
+
+### Metrics
+1. Define SLIs (Service Level Indicators)
+2. Set up SLOs (Service Level Objectives)
+3. Create dashboards for key metrics
+4. Configure alerts for threshold breaches
+
+### Tracing
+1. Propagate trace context across services
+2. Add meaningful span attributes
+3. Use semantic conventions
+4. Sample appropriately in production
+
+## Learning Resources
+
+| Resource | Description |
+|----------|-------------|
+| Mission 4432/4718 | Implement Observability in CAP Application |
+| Learning Journey | Cloud Foundry Observability |
+| Expert Portal | SAP Cloud ALM Configuration |
+
+## Source Documentation
+
+- Observability: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/establish-end-to-end-observability-34065a4.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/establish-end-to-end-observability-34065a4.md)
+- Observability Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-implement-observability-in-a-full-stack-cap-application-c5636db.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-implement-observability-in-a-full-stack-cap-application-c5636db.md)
+- SAP Cloud ALM: [https://help.sap.com/docs/cloud-alm](https://help.sap.com/docs/cloud-alm)
+- SAP Cloud Logging: [https://help.sap.com/docs/cloud-logging](https://help.sap.com/docs/cloud-logging)

references/operations.md

@@ -0,0 +1,325 @@
+# SAP BTP Operations Reference
+
+## Overview
+
+Effective administration and operations ensure stable, efficient, and cost-optimized application performance in the cloud.
+
+## Administrator Responsibilities
+
+### User and Access Management
+
+**Tasks:**
+- Identity management
+- Organizational structure setup
+- Quota allocation
+- Role assignments
+
+**Tools:**
+- SAP BTP Cockpit
+- Identity Authentication Service
+- Role Collections
+
+### Performance Monitoring
+
+**Key Metrics:**
+- System runtime
+- SQL query execution
+- Background job status
+- Response times
+- Error patterns
+
+### Resource Management
+
+**Activities:**
+- Monitor consumption patterns
+- Adjust sizing configurations
+- Leverage hibernation features
+- Cost optimization
+
+### Lifecycle Oversight
+
+**Scope:**
+- Custom application management
+- Transport processes
+- Add-on deployments
+- Multi-tenant administration
+
+### Integration Assurance
+
+**Focus:**
+- Data synchronization between cloud and on-premises
+- API health monitoring
+- Event processing status
+
+## Supporting Tools
+
+| Tool | Purpose | Environment |
+|------|---------|-------------|
+| SAP Fiori Launchpad | UI access, administration | All |
+| SAP BTP Cockpit | Platform administration | All |
+| Landscape Portal | Partner/SaaS management | ABAP |
+| Technical Monitoring Cockpit | On-stack analysis | ABAP |
+| SAP Cloud ALM | Central monitoring | All |
+| ABAP Test Cockpit | Code quality | ABAP |
+
+## Run and Scale Operations
+
+### Core Principles
+
+1. **Continuous user feedback** - Optimize based on real usage
+2. **Proactive monitoring** - Use SAP BTP observability tools
+3. **Security integration** - Protect against emerging threats
+4. **Compliance maintenance** - Regular security audits
+
+### Scaling Strategies
+
+#### Cloud Foundry
+
+**Horizontal Scaling:**
+```bash
+# Scale instances
+cf scale my-app -i 5
+
+# Scale memory
+cf scale my-app -m 1G
+```
+
+**Auto-scaling:**
+- Configure in BTP Cockpit
+- Based on CPU/memory thresholds
+- Schedule-based scaling
+
+**Availability Zones:**
+- Automatic distribution across AZs
+- Handle ~1/3 capacity loss during AZ failure
+
+#### Kyma
+
+**Horizontal Pod Autoscaler:**
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: my-app-hpa
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: my-app
+  minReplicas: 2
+  maxReplicas: 10
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target:
+          type: Utilization
+          averageUtilization: 80
+```
+
+#### ABAP Environment
+
+**Elastic Scaling:**
+- Manual ACU/HCU adjustment via BTP Cockpit
+- Automatic scaling between 1 ACU and configured maximum
+- 0.5 ACU increments
+
+**Decision Metrics:**
+- CPU usage
+- Memory consumption
+- Active work process counts
+
+### Cost Optimization
+
+#### System Hibernation (ABAP)
+
+**Benefits:**
+- Reduces costs to <5% of operational expenses
+- Preserves HANA Cloud instance
+- Automatic restart during maintenance
+
+**Management:**
+- Via Landscape Portal
+- Scheduled activation/deactivation
+- Trial accounts auto-hibernate nightly
+
+#### Resource Right-Sizing
+
+| Environment | Recommendation |
+|-------------|----------------|
+| Development | Minimal resources, hibernation |
+| Test | Moderate resources, scheduled scaling |
+| Production | Right-sized, auto-scaling enabled |
+
+## Maintenance and Upgrades
+
+### ABAP Environment Updates
+
+**Downtime-Optimized Process:**
+
+| Phase | Status | Duration |
+|-------|--------|----------|
+| Preparation | System available | Variable |
+| Takeover | Downtime | 10-40 minutes |
+| Postprocessing | System available | Background |
+
+### Pre-Upgrade Option
+
+**Purpose:** Test custom applications before standard upgrades
+
+**Guidelines:**
+- Non-development systems only
+- Available 4 weeks before release
+- Report issues via SAP support
+- Validates existing applications (not early feature access)
+
+### Security Patching
+
+**Best Practices:**
+1. Regularly apply security patches
+2. Monitor dependency vulnerabilities
+3. Test patches in non-production first
+4. Maintain patch schedule
+
+## Secure Operations
+
+### Continuous Threat Monitoring
+
+**Tools:**
+- SAP Cloud ALM
+- SAP Cloud Logging
+- Alert Notification Service
+
+**Actions:**
+- Real-time anomaly detection
+- Automated alerting
+- Incident response procedures
+
+### Secure Auto-Scaling
+
+**CAP Multitenancy:**
+- Built-in tenant isolation
+- Resource management per tenant
+- Secure scaling for SaaS
+
+### Security Audits
+
+**Schedule:** Periodic (quarterly recommended)
+
+**Scope:**
+- Configuration review
+- Compliance verification
+- Vulnerability assessment
+
+### Data Protection
+
+**Requirements:**
+- Privacy law compliance (GDPR, HIPAA)
+- Secure data handling
+- User consent management
+
+## Transport Management
+
+### gCTS (ABAP)
+
+**Flow:**
+```
+Development → Test → Production
+     ↓          ↓         ↓
+   Release    Import    Import
+```
+
+**Tools:** Manage Software Components app
+
+### SAP Cloud Transport Management (CAP)
+
+**Configuration:**
+```yaml
+transport:
+  landscape:
+    - name: DEV
+    - name: QA
+      requires: DEV
+    - name: PROD
+      requires: QA
+```
+
+## Monitoring Best Practices
+
+### Dashboards
+
+**Key Panels:**
+- Application health
+- Response times
+- Error rates
+- Resource utilization
+- Integration status
+
+### Alerts
+
+**Configuration:**
+
+| Metric | Threshold | Action |
+|--------|-----------|--------|
+| Error rate | > 1% | Page on-call |
+| Response time | > 2s | Warning email |
+| Memory | > 80% | Auto-scale or alert |
+| CPU | > 70% | Auto-scale or alert |
+
+### Log Management
+
+**Retention:**
+- Development: 7 days
+- Test: 14 days
+- Production: 30+ days
+
+**Analysis:**
+- Full-text search
+- Structured queries
+- Correlation with traces
+
+## Troubleshooting
+
+### Common Issues
+
+| Issue | Diagnosis | Resolution |
+|-------|-----------|------------|
+| High latency | Check traces | Optimize queries, scale |
+| Memory pressure | Check heap usage | Increase memory, optimize code |
+| Connection errors | Check destinations | Verify credentials, network |
+| Failed jobs | Check job logs | Fix data issues, retry |
+
+### Useful Commands
+
+**Cloud Foundry:**
+```bash
+# Recent logs
+cf logs my-app --recent
+
+# Application info
+cf app my-app
+
+# Environment variables
+cf env my-app
+
+# Events
+cf events my-app
+```
+
+**Kyma:**
+```bash
+# Pod logs
+kubectl logs -f deployment/my-app
+
+# Describe pod
+kubectl describe pod my-app-xxx
+
+# Resource usage
+kubectl top pods
+```
+
+## Source Documentation
+
+- Administrate and Operate: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/administrate-and-operate-f8fe432.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/administrate-and-operate-f8fe432.md)
+- Run and Scale: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/run-and-scale-fcb51b5.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/run-and-scale-fcb51b5.md)
+- Maintain and Upgrade: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/maintain-and-upgrade-d24bc66.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/maintain-and-upgrade-d24bc66.md)

references/partners.md

@@ -0,0 +1,301 @@
+# SAP BTP Partner Development Reference
+
+## Overview
+
+SAP BTP provides deployment options for partners (ISVs) to build and deliver ABAP and CAP-based applications as products or SaaS offerings.
+
+## Deployment Models
+
+### Multitenant SaaS
+
+**Definition**: Cloud service operated in partner's global account
+
+**Characteristics:**
+- Partner owns infrastructure
+- Customers subscribe to service
+- Partner manages operations, monitoring
+- Customers get key-user extensibility
+
+**Advantages:**
+- Single codebase for all customers
+- Centralized operations
+- Easy updates (deploy once)
+- Lower per-customer costs at scale
+
+### Add-on Product
+
+**Definition**: Product installed in customer's ABAP environment
+
+**Characteristics:**
+- Customer owns infrastructure
+- Customer manages lifecycle
+- Customer has full data control
+- Developer extensibility available
+
+**Requirements:**
+- SAP PartnerEdge Build contract
+- Distribution via SAP Store
+- Registered ABAP namespace
+
+## ABAP Partner Development
+
+### Landscape Portal
+
+**Purpose**: Central management for partner solutions
+
+**Capabilities:**
+
+| Feature | Description |
+|---------|-------------|
+| System Management | Create, configure ABAP systems |
+| Tenant Management | SaaS tenant operations |
+| Product Lifecycle | Build, register, publish products |
+| Deployment Pipelines | CI/CD for ABAP |
+| Monitoring | System and application health |
+
+### Software Components
+
+**Requirement**: At least one software component per solution
+
+**Rules:**
+- Registered ABAP namespace mandatory
+- Y*/Z* objects only within single global account
+- Multiple global accounts require add-on products
+
+### Transport Mechanisms
+
+| Tool | Use Case |
+|------|----------|
+| gCTS | BTP system-to-system transports (recommended) |
+| abapGit | On-premise migration, backup, cross-account |
+| Landscape Portal Products | Multi-account delivery |
+
+### Namespace Requirements
+
+**Mandatory**: All objects in a Product require registered namespace
+
+**Process:**
+1. Request namespace from SAP
+2. Register in development system
+3. Use namespace prefix for all objects
+
+## CAP Partner Development
+
+### Poetry Slam Manager
+
+**Type**: Reference application for multitenant CAP SaaS
+
+**GitHub**: [https://github.com/SAP-samples/partner-reference-application/](https://github.com/SAP-samples/partner-reference-application/)
+
+**Demonstrates:**
+- Full-stack cloud applications using SAP Cloud Application Programming Model (CAP)
+- Multitenant architecture aligned with SAP BTP Developer's Guide
+- ERP-agnostic design (compatible with S/4HANA Cloud, Business One, Business ByDesign)
+- Subscription lifecycle management
+- Cost optimization patterns
+
+**Tutorial Structure:**
+1. Core application development (business models, logic)
+2. Enhancement to multitenant (multi-customer) solutions
+3. ERP backend integration
+4. Feature expansion
+5. Application extension
+
+**Bill of Materials**: Complete service list at [https://github.com/SAP-samples/partner-reference-application/blob/main/Tutorials/01-BillOfMaterials.md](https://github.com/SAP-samples/partner-reference-application/blob/main/Tutorials/01-BillOfMaterials.md)
+
+### Partner Reference Application Extension
+
+**Type**: Customer-specific extension example
+
+**GitHub**: [https://github.com/SAP-samples/partner-reference-application-extension](https://github.com/SAP-samples/partner-reference-application-extension)
+
+**Demonstrates:**
+- Enhanced catering management capabilities
+- Seamless base application integration
+- Granular tenant-specific configurations
+- Consistent UX across extended and core features
+- Secure multitenant architecture with data isolation
+
+## ABAP Sample Application
+
+### Music Festival Manager
+
+**Type**: Reference application for multitenant ABAP SaaS
+
+**GitHub**: [https://github.com/SAP-samples/abap-platform-partner-reference-application](https://github.com/SAP-samples/abap-platform-partner-reference-application)
+
+**Demonstrates:**
+- Full-stack ABAP Cloud development using RAP
+- Scalable, multitenant architecture
+- SAP BTP Developer's Guide best practices
+- ERP-agnostic design (side-by-side extensions)
+- Compatibility with any SAP solution including S/4HANA Cloud ERP
+
+**Tutorial Structure:**
+1. **Core Application Development**: Business models, logic, UI, authentication, role-based authorization
+2. **Deployment & Provisioning**: Building and deploying to consumers
+3. **SAP S/4HANA Cloud Integration**: Connecting with enterprise systems
+4. **Feature Enhancement**: Expanding application capabilities
+
+**Key Features:**
+- Uses ABAP RESTful Application Programming Model (RAP)
+- Leverages SAP BTP services for enterprise-class standards
+- Enables focus on business logic and domain functionality
+
+## Cost Estimation
+
+### Total Cost of Ownership Calculator
+
+**Location**: SAP Partner Portal
+
+**Inputs:**
+- Expected tenant count
+- Resource requirements
+- Support level
+- Region
+
+**Outputs:**
+- Monthly operational costs
+- Per-tenant estimates
+- Scaling projections
+
+## Development Workflow
+
+### SaaS Development Flow
+
+```
+1. Setup
+   ├── Create global account
+   ├── Configure Landscape Portal
+   └── Setup development system
+
+2. Develop
+   ├── Build software components
+   ├── Implement business logic
+   ├── Create Fiori apps
+   └── Configure multitenancy
+
+3. Test
+   ├── Unit testing (ABAP Unit)
+   ├── Integration testing
+   ├── Tenant isolation testing
+   └── Performance testing
+
+4. Deploy
+   ├── Build product
+   ├── Register in Landscape Portal
+   └── Publish to SAP Store (optional)
+
+5. Operate
+   ├── Monitor via SAP Cloud ALM
+   ├── Manage subscriptions
+   └── Handle support requests
+```
+
+### Add-on Development Flow
+
+```
+1. Develop
+   ├── Create software components
+   ├── Use registered namespace
+   └── Follow ABAP Cloud guidelines
+
+2. Build
+   ├── Assemble product via Landscape Portal
+   ├── Run quality checks
+   └── Create release
+
+3. Distribute
+   ├── Register in SAP Store
+   ├── Define pricing
+   └── Enable discovery
+
+4. Support
+   ├── Customer installation support
+   ├── Update delivery
+   └── Issue resolution
+```
+
+## Key User Extensibility (SaaS)
+
+**Available to customers:**
+- UI adaptations
+- Custom fields
+- Custom logic (BAdIs)
+- Business configuration
+
+**Not available:**
+- Database schema changes
+- Core code modifications
+- Direct system access
+
+## Tenant Management
+
+### Subscription Lifecycle
+
+```
+Customer Subscription Request
+         ↓
+Tenant Provisioning (automatic)
+         ↓
+Tenant Configuration
+         ↓
+User Access Setup
+         ↓
+Operational Phase
+         ↓
+[Optional] Tenant Offboarding
+```
+
+### Isolation Guarantees
+
+| Aspect | Isolation Level |
+|--------|-----------------|
+| Data | Complete (separate schemas) |
+| Configuration | Per-tenant |
+| Customizations | Per-tenant |
+| Resources | Shared compute, isolated data |
+
+## Best Practices
+
+### Architecture
+
+1. **Design for multitenancy** from the start
+2. **Implement proper tenant isolation**
+3. **Use SAP-recommended patterns**
+4. **Plan for scale** (up to 1000 tenants per HANA instance)
+
+### Development
+
+1. **Follow ABAP Cloud guidelines**
+2. **Use ATC for quality checks**
+3. **Implement comprehensive testing**
+4. **Document APIs and extensions**
+
+### Operations
+
+1. **Monitor with SAP Cloud ALM**
+2. **Automate deployments**
+3. **Plan upgrade windows**
+4. **Establish support processes**
+
+### Pricing
+
+1. **Calculate TCO accurately**
+2. **Consider scaling costs**
+3. **Plan for support overhead**
+4. **Offer flexible pricing tiers**
+
+## Resources
+
+| Resource | Location |
+|----------|----------|
+| Partner Portal | partner.sap.com |
+| Discovery Center | discovery-center.cloud.sap |
+| PartnerEdge Build | SAP PartnerEdge program |
+| Reference Applications | github.com/SAP-samples |
+
+## Source Documentation
+
+- ISV ABAP Guide: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/build-and-run-abap-applications-for-partners-who-are-independent-software-vendors-210db8e.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/build-and-run-abap-applications-for-partners-who-are-independent-software-vendors-210db8e.md)
+- ISV SaaS Guide: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/build-and-run-multitenant-saas-applications-for-partners-who-are-independent-software-ven-9b5e06f.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/build-and-run-multitenant-saas-applications-for-partners-who-are-independent-software-ven-9b5e06f.md)

references/resilience.md

@@ -0,0 +1,323 @@
+# SAP BTP Resilience Reference
+
+## Overview
+
+Building resilient applications ensures stability, high availability, and graceful degradation during failures. SAP BTP provides patterns and services to achieve enterprise-grade resilience.
+
+## Key Resources
+
+| Resource | Description |
+|----------|-------------|
+| Developing Resilient Apps on SAP BTP | Patterns and examples |
+| Route Multi-Region Traffic | GitHub implementation |
+| Architecting Multi-Region Resiliency | Discovery Center reference |
+
+## Cloud Foundry Resilience
+
+### Availability Zones
+
+**Automatic Distribution:**
+- Applications spread across multiple AZs
+- No manual configuration required
+- Platform handles placement
+
+**During AZ Failure:**
+- ~1/3 instances become unavailable (3-zone deployment)
+- Remaining instances handle increased load
+- Cloud Foundry reschedules to healthy zones
+
+**Best Practice:**
+Configure sufficient instances to handle load during zone failures:
+```
+Minimum instances = Normal load instances × 1.5
+```
+
+### Instance Configuration
+
+```yaml
+# manifest.yml
+applications:
+  - name: my-app
+    instances: 3  # At least 3 for HA
+    memory: 512M
+    health-check-type: http
+    health-check-http-endpoint: /health
+```
+
+### Health Checks
+
+```javascript
+// Express health endpoint
+app.get('/health', (req, res) => {
+  const health = {
+    status: 'UP',
+    checks: {
+      database: checkDatabase(),
+      messaging: checkMessaging()
+    }
+  };
+  res.status(200).json(health);
+});
+```
+
+## Kyma Resilience
+
+### Istio Service Mesh
+
+**Features:**
+- Automatic retries
+- Circuit breakers
+- Timeouts
+- Load balancing
+
+### Configuration
+
+```yaml
+apiVersion: networking.istio.io/v1alpha3
+kind: DestinationRule
+metadata:
+  name: my-app-dr
+spec:
+  host: my-app
+  trafficPolicy:
+    connectionPool:
+      tcp:
+        maxConnections: 100
+      http:
+        h2UpgradePolicy: UPGRADE
+        http1MaxPendingRequests: 100
+        http2MaxRequests: 1000
+    outlierDetection:
+      consecutive5xxErrors: 5
+      interval: 30s
+      baseEjectionTime: 30s
+      maxEjectionPercent: 50
+```
+
+### Pod Distribution
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+spec:
+  replicas: 3
+  template:
+    spec:
+      topologySpreadConstraints:
+        - maxSkew: 1
+          topologyKey: topology.kubernetes.io/zone
+          whenUnsatisfiable: DoNotSchedule
+          labelSelector:
+            matchLabels:
+              app: my-app
+```
+
+## ABAP Resilience
+
+### Built-in Features
+
+- Automatic workload distribution
+- Work process management
+- HANA failover support
+- Session management
+
+### Elastic Scaling
+
+Automatic response to load:
+- Scale between 1 ACU and configured max
+- 0.5 ACU increments
+- Metrics-based decisions
+
+## Resilience Patterns
+
+### Circuit Breaker
+
+**Purpose**: Prevent cascading failures
+
+**States:**
+1. **Closed**: Normal operation
+2. **Open**: Fail fast, skip calls
+3. **Half-Open**: Test recovery
+
+**Implementation (CAP - Node.js):**
+
+> **Note**: The `opossum` library shown below is a third-party community package, not SAP-supported. Evaluate its maintenance status, compatibility with your CAP/Node.js versions, and security posture before production use. For Java applications, SAP Cloud SDK integrates with Resilience4j as the official resilience tooling.
+
+```javascript
+const CircuitBreaker = require('opossum');
+
+const breaker = new CircuitBreaker(callRemoteService, {
+  timeout: 3000,
+  errorThresholdPercentage: 50,
+  resetTimeout: 30000
+});
+
+breaker.fallback(() => getCachedData());
+
+const result = await breaker.fire(serviceParams);
+```
+
+### Retry with Exponential Backoff
+
+**Purpose**: Handle transient failures
+
+```javascript
+async function retryWithBackoff(fn, maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === maxRetries - 1) throw error;
+      const delay = Math.pow(2, i) * 1000;
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+}
+```
+
+### Bulkhead
+
+**Purpose**: Isolate failures
+
+```javascript
+const Semaphore = require('semaphore');
+
+const dbPool = Semaphore(10);  // Max 10 concurrent DB calls
+const apiPool = Semaphore(20); // Max 20 concurrent API calls
+
+async function callDatabase() {
+  return new Promise((resolve, reject) => {
+    dbPool.take(() => {
+      performDbCall()
+        .then(resolve)
+        .catch(reject)
+        .finally(() => dbPool.leave());
+    });
+  });
+}
+```
+
+### Timeout
+
+**Purpose**: Prevent hanging requests
+
+```javascript
+const timeout = (promise, ms) => {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Timeout')), ms)
+    )
+  ]);
+};
+
+const result = await timeout(fetchData(), 5000);
+```
+
+### Graceful Degradation
+
+**Purpose**: Provide reduced functionality instead of failing
+
+```javascript
+async function getProductDetails(id) {
+  try {
+    // Try full data
+    return await getFromPrimaryService(id);
+  } catch (error) {
+    // Fallback to cached/reduced data
+    const cached = await getFromCache(id);
+    if (cached) return { ...cached, _degraded: true };
+
+    // Final fallback
+    return getBasicDetails(id);
+  }
+}
+```
+
+## Multi-Region Architecture
+
+### Active-Passive
+
+```
+Region A (Primary)     Region B (Standby)
+     ↓                      ↓
+  Active                 Standby
+     ↓                      ↓
+  HANA Cloud           HANA Cloud (Replica)
+```
+
+**Failover**: Manual or automated switch
+
+### Active-Active
+
+```
+        Global Load Balancer
+              ↓
+    ┌─────────┴─────────┐
+    ↓                   ↓
+Region A              Region B
+    ↓                   ↓
+HANA Cloud           HANA Cloud
+    ↓                   ↓
+    └───── Replication ─┘
+```
+
+**Use Case**: Highest availability requirements
+
+## Monitoring for Resilience
+
+### Key Metrics
+
+| Metric | Threshold | Action |
+|--------|-----------|--------|
+| Error rate | > 1% | Alert, investigate |
+| Latency p99 | > 2s | Scale, optimize |
+| Circuit breaker trips | Any | Review dependencies |
+| Retry rate | > 5% | Check downstream services |
+
+### Alerting
+
+```yaml
+# SAP Alert Notification example
+conditions:
+  - name: high-error-rate
+    propertyKey: error_rate
+    predicate: GREATER_THAN
+    propertyValue: "0.01"
+
+actions:
+  - name: page-oncall
+    type: EMAIL
+    properties:
+      destination: oncall@example.com
+```
+
+## Best Practices
+
+### Design
+
+1. **Assume failure** - Everything can fail
+2. **Design for graceful degradation**
+3. **Implement health checks**
+4. **Use async where possible**
+5. **Plan for data consistency**
+
+### Implementation
+
+1. **Set timeouts** on all external calls
+2. **Implement retries** with backoff
+3. **Use circuit breakers** for dependencies
+4. **Cache aggressively** where appropriate
+5. **Log and monitor** all failures
+
+### Operations
+
+1. **Run chaos engineering** tests
+2. **Practice disaster recovery**
+3. **Monitor SLIs/SLOs**
+4. **Automate failover** where possible
+
+## Source Documentation
+
+- Developing Resilient Applications: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/developing-resilient-applications-b1b929a.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/developing-resilient-applications-b1b929a.md)
+- SAP BTP Resilience Guide: [https://help.sap.com/docs/btp/best-practices/developing-resilient-apps](https://help.sap.com/docs/btp/best-practices/developing-resilient-apps)

references/runtimes.md

@@ -0,0 +1,156 @@
+# SAP BTP Runtimes Comparison Reference
+
+## Overview
+
+SAP BTP provides flexible runtime options allowing development teams to select environments based on technical requirements, developer skills, and cost considerations.
+
+## Runtime Options
+
+### 1. Cloud Foundry Runtime
+
+**Best For**: Traditional PaaS applications, rapid deployment
+
+**Characteristics:**
+- Managed application runtime
+- Buildpack-based deployments
+- Simple scaling with `cf scale`
+- Memory-based billing
+
+**Languages:**
+- Node.js
+- Java
+- Python
+- Go
+- PHP
+
+**Use Cases:**
+- Cloud-native applications
+- Microservices
+- API backends
+- Scheduled jobs
+
+### 2. Kyma Runtime
+
+**Best For**: Kubernetes-native applications, containerized workloads
+
+**Characteristics:**
+- Managed Kubernetes cluster
+- Istio service mesh included
+- Helm-based deployments
+- Container-based billing
+
+**Technologies:**
+- Kubernetes
+- Docker containers
+- Helm charts
+- Istio service mesh
+- Serverless functions
+
+**Use Cases:**
+- Container-based applications
+- Microservices with service mesh
+- Event-driven architectures
+- Custom runtime requirements
+
+### 3. ABAP Environment
+
+**Best For**: Organizations with ABAP expertise, SAP extensions
+
+**Characteristics:**
+- Managed ABAP platform
+- RAP programming model
+- Integrated SAP Fiori Launchpad
+- ACU/HCU-based billing
+
+**Languages:**
+- ABAP (restricted cloud-safe subset)
+
+**Use Cases:**
+- SAP S/4HANA extensions
+- Enterprise business applications
+- Migrating ABAP custom code
+- ISV solutions
+
+## Comparison Matrix
+
+| Aspect | Cloud Foundry | Kyma | ABAP Environment |
+|--------|--------------|------|------------------|
+| **Programming** | Node.js, Java, Python | Any containerized | ABAP Cloud |
+| **Deployment** | cf push / MTA | Helm / kubectl | gCTS / Landscape Portal |
+| **Scaling** | Horizontal (instances) | Kubernetes pods | Elastic ACUs |
+| **Persistence** | HANA Cloud, PostgreSQL | HANA Cloud, any | HANA Cloud (managed) |
+| **UI** | SAPUI5, Fiori Elements | Any | Fiori Elements |
+| **Billing Model** | Memory consumption | Cluster + resources | ACU + HCU |
+
+## Metering Details
+
+### Cloud Foundry
+- **Start**: When runtime memory is consumed (e.g., application deployment)
+- **Metric**: GB-hours of memory
+- **Optimization**: Stop unused applications, right-size memory
+
+### Kyma
+- **Start**: When Kyma runtime is enabled (cluster creation)
+- **Metric**: Dedicated Kubernetes cluster resources
+- **Optimization**: Node autoscaling, resource limits
+
+### ABAP Environment
+- **Start**: When ABAP system is provisioned
+- **Metric**: ABAP Compute Units (ACU) + HANA Compute Units (HCU)
+- **Optimization**: System hibernation, elastic scaling
+
+## Choosing a Runtime
+
+### Choose Cloud Foundry When:
+- Developing CAP applications with Node.js or Java
+- Need simple deployment model
+- Want buildpack-managed dependencies
+- Cost-sensitive workloads
+
+### Choose Kyma When:
+- Need Kubernetes-native features
+- Require service mesh (Istio)
+- Building container-based microservices
+- Need serverless functions
+- Custom runtime requirements
+
+### Choose ABAP Environment When:
+- Have existing ABAP expertise
+- Extending SAP S/4HANA
+- Need tight SAP integration
+- Building partner add-on products
+- Migrating custom ABAP code
+
+## CAP Support Across Runtimes
+
+### Cloud Foundry
+```bash
+# Deploy CAP to Cloud Foundry
+mbt build
+cf deploy mta_archives/my-app.mtar
+```
+
+### Kyma
+```bash
+# Deploy CAP to Kyma
+cds add helm
+helm upgrade --install my-app ./chart
+```
+
+### ABAP (Not CAP)
+- Use RAP (ABAP RESTful Application Programming Model)
+- Different programming model, similar concepts
+
+## Runtime-Specific Documentation
+
+| Runtime | Documentation |
+|---------|--------------|
+| Cloud Foundry | [https://help.sap.com/docs/btp/sap-business-technology-platform/cloud-foundry-environment](https://help.sap.com/docs/btp/sap-business-technology-platform/cloud-foundry-environment) |
+| Kyma | [https://help.sap.com/docs/btp/sap-business-technology-platform/kyma-environment](https://help.sap.com/docs/btp/sap-business-technology-platform/kyma-environment) |
+| ABAP | [https://help.sap.com/docs/btp/sap-business-technology-platform/abap-environment](https://help.sap.com/docs/btp/sap-business-technology-platform/abap-environment) |
+
+## Source Documentation
+
+- Runtime Benefits: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/strengths-and-benefits-of-the-runtimes-and-their-programming-models-86688d1.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/strengths-and-benefits-of-the-runtimes-and-their-programming-models-86688d1.md)
+- CF/Kyma with CAP: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-cloud-foundry-and-sap-btp-kyma-runtimes-with-cap-0f9cfe9.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-cloud-foundry-and-sap-btp-kyma-runtimes-with-cap-0f9cfe9.md)
+- ABAP Environment: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-abap-environment-with-abap-cloud-174b229.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/sap-btp-abap-environment-with-abap-cloud-174b229.md)

references/security.md

@@ -0,0 +1,327 @@
+# SAP BTP Security Reference
+
+## Overview
+
+Security must be integrated throughout the development lifecycle, from initial design through production operations. SAP BTP provides platform-level security with platform roles, segregation of duties, and audit logging with digital signatures.
+
+## Security by Development Phase
+
+### Explore Phase
+
+| Guideline | Action |
+|-----------|--------|
+| Secure SDLC Framework | Implement OWASP-aligned development standards |
+| Engagement & Training | Clarify stakeholder expectations, train teams |
+| Risk Assessment | Identify high-level security risks |
+| Threat Modeling | Evaluate industry-specific threats |
+| Compliance Planning | Determine applicable regulations (GDPR, HIPAA) |
+
+### Discover Phase
+
+| Guideline | Action |
+|-----------|--------|
+| Map Data Flows | Document sensitive data movement using OWASP Threat Dragon |
+| Establish Secure Architecture | Microservice isolation, least privilege, defense-in-depth |
+| Validate Third-Party Services | Review security certifications |
+| Security in Prototypes | Include input sanitization, mock authentication |
+| Plan Data Protection | Anonymize user research data |
+| Understand Boundary Conditions | Assess IAM and audit logging integration |
+
+### Design Phase
+
+| Guideline | Focus |
+|-----------|-------|
+| Secure User Interfaces | SAP Fiori authentication and validation |
+| Access Control Models | RBAC/ABAC using OpenID Connect/OAuth |
+| API Security | OAuth and TLS encryption |
+| Secure Extensibility | Isolate and validate custom logic |
+| Domain Model Validation | Review CDS models for data protection |
+
+### Run and Scale Phase
+
+| Guideline | Focus |
+|-----------|-------|
+| Continuous Threat Monitoring | SAP BTP observability tools |
+| Security Patching | Regular updates to dependencies |
+| Secure Auto-Scaling | Tenant isolation in multitenancy |
+| Security Audits | Periodic compliance reviews |
+| Data Protection | Privacy law compliance |
+
+## Common Runtime Threats
+
+| Threat | Description | CAP Mitigation |
+|--------|-------------|----------------|
+| SQL Injection | Malicious SQL in inputs | Parameterized queries |
+| XSS | Script injection in UI | Input validation |
+| CSRF | Unauthorized actions | Built-in CSRF protection |
+| Authentication Bypass | Improper session handling | XSUAA integration |
+
+## CAP Security Implementation
+
+### Authentication Setup
+
+```bash
+# Add authentication
+cds add xsuaa
+```
+
+### xs-security.json Configuration
+```json
+{
+  "xsappname": "my-app",
+  "tenant-mode": "dedicated",
+  "scopes": [
+    {
+      "name": "$XSAPPNAME.Read",
+      "description": "Read access"
+    },
+    {
+      "name": "$XSAPPNAME.Write",
+      "description": "Write access"
+    },
+    {
+      "name": "$XSAPPNAME.Admin",
+      "description": "Admin access"
+    }
+  ],
+  "role-templates": [
+    {
+      "name": "Viewer",
+      "scope-references": ["$XSAPPNAME.Read"]
+    },
+    {
+      "name": "Editor",
+      "scope-references": ["$XSAPPNAME.Read", "$XSAPPNAME.Write"]
+    },
+    {
+      "name": "Administrator",
+      "scope-references": ["$XSAPPNAME.Read", "$XSAPPNAME.Write", "$XSAPPNAME.Admin"]
+    }
+  ]
+}
+```
+
+### CDS Authorization
+
+```cds
+// Role-based access control
+service CatalogService @(requires: 'authenticated-user') {
+
+  @(restrict: [
+    { grant: 'READ', to: 'Viewer' },
+    { grant: ['READ', 'WRITE'], to: 'Editor' },
+    { grant: '*', to: 'Administrator' }
+  ])
+  entity Books as projection on bookshop.Books;
+
+  // Instance-based authorization
+  @(restrict: [
+    { grant: 'READ', where: 'createdBy = $user' },
+    { grant: '*', to: 'Administrator' }
+  ])
+  entity Orders as projection on bookshop.Orders;
+}
+```
+
+### Input Validation
+```cds
+entity Books {
+  key ID : UUID;
+  title : String(100) @mandatory;
+  price : Decimal(10,2) @assert.range: [0, 9999.99];
+  isbn : String(13) @assert.format: '^[0-9]{13}$';
+}
+```
+
+## ABAP Security
+
+### Authorization Objects
+```abap
+AUTHORITY-CHECK OBJECT 'S_DEVELOP'
+  ID 'DEVCLASS' FIELD iv_package
+  ID 'OBJTYPE' FIELD 'CLAS'
+  ID 'ACTVT' FIELD '02'.
+
+IF sy-subrc <> 0.
+  RAISE EXCEPTION TYPE cx_no_authorization.
+ENDIF.
+```
+
+### RAP Authorization
+```abap
+define behavior for ZI_Travel alias Travel
+authorization master ( instance )
+{
+  // Authorization check on entity level
+}
+```
+
+### Behavior Implementation
+```abap
+METHOD get_instance_authorizations.
+  DATA(lv_auth) = abap_false.
+
+  " Check authorization for specific instance
+  AUTHORITY-CHECK OBJECT 'ZTRAVEL'
+    ID 'TRAVEL_ID' FIELD keys[ 1 ]-TravelID
+    ID 'ACTVT' FIELD '02'.
+
+  IF sy-subrc = 0.
+    lv_auth = abap_true.
+  ENDIF.
+
+  result = VALUE #( FOR key IN keys
+    ( %tky = key-%tky
+      %update = COND #( WHEN lv_auth = abap_true THEN if_abap_behv=>auth-allowed
+                        ELSE if_abap_behv=>auth-unauthorized ) ) ).
+ENDMETHOD.
+```
+
+## Authentication Services
+
+### SAP Authentication and Trust Management (XSUAA)
+
+**Purpose**: Manage user authorizations
+
+**Features:**
+- OAuth 2.0 / OpenID Connect
+- SAML 2.0 federation
+- User attribute mapping
+- Role collections
+
+### Identity Authentication Service (IAS)
+
+**Purpose**: Cloud-based identity management
+
+**Features:**
+- Single Sign-On (SSO)
+- Multi-factor authentication
+- Social login integration
+- On-premise IdP integration
+
+### Configuration
+```yaml
+# mta.yaml
+resources:
+  - name: my-xsuaa
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      service-plan: application
+      config:
+        xsappname: my-app
+        tenant-mode: dedicated
+
+  - name: my-ias
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: identity
+      service-plan: application
+```
+
+## Secrets Management
+
+### SAP Credential Store (CAP)
+
+**Use Cases:**
+- API keys
+- Database credentials
+- Third-party service tokens
+
+**Access via REST API:**
+```javascript
+const { CredentialStore } = require('@sap/credential-store');
+
+const credStore = new CredentialStore();
+const password = await credStore.readPassword('namespace', 'key');
+```
+
+### ABAP Communication Management
+
+- Integrated credentials store
+- Outbound communication configuration
+- Certificate management
+
+## Audit Logging
+
+### CAP Audit Log Service
+```javascript
+const cds = require('@sap/cds');
+const audit = cds.connect.to('audit-log');
+
+// Log data access
+await audit.log({
+  type: 'DATA_READ',
+  data_subject: { type: 'Customer', id: customerId },
+  attributes: ['name', 'email']
+});
+```
+
+### ABAP Audit Logging
+
+**Security Audit Log:**
+- Automatic for security-relevant events
+- Configurable event classes
+
+**Read Access Logging (RAL):**
+- Sensitive data access monitoring
+- Compliance reporting
+
+## Data Privacy
+
+### SAP Data Privacy Integration
+
+**Capabilities:**
+- Cross-application privacy features
+- End-to-end compliance support
+- Data subject access requests
+
+### Personal Data Handling (CAP)
+```cds
+entity Customers {
+  key ID : UUID;
+  @PersonalData.FieldSemantics: 'DataSubjectID'
+  customerID : String;
+  @PersonalData.IsPotentiallyPersonal
+  name : String;
+  @PersonalData.IsPotentiallyPersonal
+  email : String;
+}
+```
+
+## Security Best Practices
+
+### Environment Configuration
+- Restrict network access
+- Use private endpoints where possible
+- Enable WAF protection
+
+### Deployment Pipelines
+- Code scanning in CI/CD
+- Dependency vulnerability checks
+- Container image scanning
+
+### Secrets
+- Never hardcode credentials
+- Rotate secrets regularly
+- Use managed services
+
+### Network
+- TLS 1.2+ for all connections
+- Certificate pinning where appropriate
+- IP allowlisting for sensitive services
+
+## Compliance Resources
+
+| Standard | SAP BTP Support |
+|----------|-----------------|
+| GDPR | Data Privacy Integration, audit logging |
+| SOC 2 | SAP compliance certifications |
+| ISO 27001 | Platform certifications |
+| HIPAA | Healthcare-specific controls |
+
+## Source Documentation
+
+- Security Considerations: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/security-considerations-for-applications-a73f6ff.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/security-considerations-for-applications-a73f6ff.md)
+- CAP Security Guide: [https://cap.cloud.sap/docs/guides/security/](https://cap.cloud.sap/docs/guides/security/)
+- SAP BTP Security Recommendations: [https://help.sap.com/docs/btp/sap-btp-security-recommendations/sap-btp-security-recommendations](https://help.sap.com/docs/btp/sap-btp-security-recommendations/sap-btp-security-recommendations)

references/setup.md

@@ -0,0 +1,334 @@
+# SAP BTP Setup Reference
+
+## Overview
+
+Setting up SAP BTP landscape is an administrative task that involves configuring account structures, users, and infrastructure automation.
+
+## Account Model
+
+### Hierarchy
+
+```
+Global Account
+├── Directory (optional)
+│   ├── Subaccount (DEV)
+│   ├── Subaccount (QA)
+│   └── Subaccount (PROD)
+└── Subaccount (Shared Services)
+```
+
+### Subaccount Configuration
+
+Each subaccount can have:
+- Cloud Foundry environment
+- Kyma environment
+- ABAP environment
+- Service instances
+- Role assignments
+
+## User Types
+
+### Platform Users
+
+**Role**: Developers, administrators, operators
+
+**Responsibilities**:
+- Application deployment
+- System administration
+- Troubleshooting
+- Operations
+
+**Access**: Subaccounts, services, runtimes
+
+### Business Users
+
+**Role**: End users of applications
+
+**Access**: Deployed applications, SaaS services
+
+## Terraform Provider for SAP BTP
+
+### Overview
+
+**Purpose**: Automate provisioning, management, and configuration
+
+**Benefits**:
+- Infrastructure as code
+- Reproducible deployments
+- Version-controlled configuration
+- CI/CD integration
+
+### Installation
+
+```hcl
+# main.tf
+terraform {
+  required_providers {
+    btp = {
+      source  = "SAP/btp"
+      version = "~> 1.0"
+    }
+  }
+}
+
+provider "btp" {
+  globalaccount = var.globalaccount
+}
+```
+
+### Common Resources
+
+#### Subaccount
+
+```hcl
+resource "btp_subaccount" "dev" {
+  name      = "development"
+  subdomain = "dev-${var.org_id}"
+  region    = "eu10"
+  labels = {
+    environment = "development"
+  }
+}
+```
+
+#### Entitlements
+
+```hcl
+resource "btp_subaccount_entitlement" "hana" {
+  subaccount_id = btp_subaccount.dev.id
+  service_name  = "hana-cloud"
+  plan_name     = "hana"
+  amount        = 1
+}
+
+resource "btp_subaccount_entitlement" "cf" {
+  subaccount_id = btp_subaccount.dev.id
+  service_name  = "APPLICATION_RUNTIME"
+  plan_name     = "MEMORY"
+}
+```
+
+#### Service Instances
+
+```hcl
+resource "btp_subaccount_service_instance" "xsuaa" {
+  subaccount_id  = btp_subaccount.dev.id
+  name           = "my-xsuaa"
+  serviceplan_id = data.btp_subaccount_service_plan.xsuaa.id
+  parameters = jsonencode({
+    xsappname   = "my-app"
+    tenant-mode = "dedicated"
+  })
+}
+```
+
+#### Role Collections
+
+```hcl
+resource "btp_subaccount_role_collection_assignment" "admin" {
+  subaccount_id        = btp_subaccount.dev.id
+  role_collection_name = "Subaccount Administrator"
+  user_name           = "admin@example.com"
+}
+```
+
+### Complete Example
+
+```hcl
+# variables.tf
+variable "globalaccount" {
+  description = "Global account subdomain"
+  type        = string
+}
+
+variable "region" {
+  description = "BTP region"
+  type        = string
+  default     = "eu10"
+}
+
+variable "admins" {
+  description = "List of admin users"
+  type        = list(string)
+}
+
+# main.tf
+terraform {
+  required_providers {
+    btp = {
+      source  = "SAP/btp"
+      version = "~> 1.0"
+    }
+  }
+}
+
+provider "btp" {
+  globalaccount = var.globalaccount
+}
+
+# Development subaccount
+resource "btp_subaccount" "dev" {
+  name      = "Development"
+  subdomain = "dev-myorg"
+  region    = var.region
+}
+
+# Enable Cloud Foundry
+resource "btp_subaccount_entitlement" "cf" {
+  subaccount_id = btp_subaccount.dev.id
+  service_name  = "APPLICATION_RUNTIME"
+  plan_name     = "MEMORY"
+}
+
+resource "btp_subaccount_environment_instance" "cf" {
+  subaccount_id    = btp_subaccount.dev.id
+  name             = "cf-dev"
+  environment_type = "cloudfoundry"
+  service_name     = "cloudfoundry"
+  plan_name        = "standard"
+  parameters = jsonencode({
+    instance_name = "cf-dev"
+  })
+}
+
+# HANA Cloud
+resource "btp_subaccount_entitlement" "hana" {
+  subaccount_id = btp_subaccount.dev.id
+  service_name  = "hana-cloud"
+  plan_name     = "hana"
+  amount        = 1
+}
+
+# Admin role assignment
+resource "btp_subaccount_role_collection_assignment" "admins" {
+  for_each = toset(var.admins)
+
+  subaccount_id        = btp_subaccount.dev.id
+  role_collection_name = "Subaccount Administrator"
+  user_name           = each.value
+}
+
+# outputs.tf
+output "subaccount_id" {
+  value = btp_subaccount.dev.id
+}
+
+output "cf_api_endpoint" {
+  value = btp_subaccount_environment_instance.cf.labels["API Endpoint"]
+}
+```
+
+### Terraform Commands
+
+```bash
+# Initialize
+terraform init
+
+# Plan changes
+terraform plan -var-file="dev.tfvars"
+
+# Apply changes
+terraform apply -var-file="dev.tfvars"
+
+# Destroy resources
+terraform destroy -var-file="dev.tfvars"
+```
+
+## Manual Setup Steps
+
+### 1. Global Account Configuration
+
+1. Access SAP BTP Cockpit
+2. Navigate to Global Account
+3. Configure directories (optional)
+4. Set up entitlements
+
+### 2. Subaccount Creation
+
+1. Click "Create Subaccount"
+2. Specify name and subdomain
+3. Select region
+4. Configure labels
+5. Enable environments
+
+### 3. Entitlement Assignment
+
+1. Navigate to Entitlements
+2. Configure Service Assignments
+3. Set quotas per service
+4. Assign to subaccounts
+
+### 4. User Management
+
+1. Navigate to Security > Users
+2. Add users by email
+3. Assign role collections
+4. Configure IdP trust (optional)
+
+## ABAP System Landscape Setup
+
+### Recommended Landscapes
+
+Start with only needed systems. Additional systems can be provisioned later.
+
+**3-System Landscape (DEV, QAS, PRD)**
+- Recommended for most projects
+- Suitable when development is occasional or release cycles are less frequent
+- Enables testing outside development
+- Verifies application behavior before production
+
+**5-System Landscape (DEV, COR, TST, QAS, PRD)**
+- Appropriate for larger teams with continuous development
+- Enables parallel correction handling
+- Supports uninterrupted development work
+
+### Sizing Specifications
+
+**Production Capacity:**
+- 1 ACU can serve up to **1,000 active business users per day**
+
+**Recommended Minimum Starting Configuration:**
+
+| Resource | Size | Memory |
+|----------|------|--------|
+| ABAP Compute Units (ACU) | 1 | 16 GB |
+| HANA Compute Units (HCU) | 2 | 32 GB total |
+
+**Scaling Options:**
+- Manual scaling via SAP BTP Cockpit
+- Automatic runtime scaling (Release 2402+) requires consumption-based contract
+
+**Cost Optimization:**
+- Use system hibernation for DEV, COR, TST systems during inactive periods
+- Reduces costs significantly when systems not in use
+
+## Best Practices
+
+### Account Structure
+
+| Environment | Purpose | Entitlements |
+|-------------|---------|--------------|
+| Development | Development work | Full entitlements |
+| QA/Test | Testing | Production-like |
+| Production | Live workloads | Production quotas |
+| Sandbox | Experimentation | Minimal |
+
+### Security
+
+1. **Least privilege** - Minimal necessary permissions
+2. **Separation of duties** - Different roles for different tasks
+3. **Audit logging** - Enable for compliance
+4. **IdP integration** - Use corporate identity
+
+### Automation
+
+1. **Use Terraform** for reproducibility
+2. **Version control** configurations
+3. **CI/CD integration** for changes
+4. **Document** manual steps
+
+## Source Documentation
+
+- Setup: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/set-up-3b774f8.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/set-up-3b774f8.md)
+- SAP BTP Administrator's Guide: [https://help.sap.com/docs/btp/sap-business-technology-platform/administration-and-operations](https://help.sap.com/docs/btp/sap-business-technology-platform/administration-and-operations)
+- Terraform Provider: [https://registry.terraform.io/providers/SAP/btp/latest](https://registry.terraform.io/providers/SAP/btp/latest)

references/testing.md

@@ -0,0 +1,400 @@
+# SAP BTP Testing Reference
+
+## Overview
+
+Quality assurance requires comprehensive testing across multiple dimensions including UI, usability, performance, and unit testing.
+
+## Testing Strategy
+
+### Test Pyramid
+
+```
+        /\
+       /  \     E2E/UI Tests (few, slow)
+      /----\
+     /      \   Integration Tests (some)
+    /--------\
+   /          \  Unit Tests (many, fast)
+  /------------\
+```
+
+### Benefits of Unit Testing
+
+- Detect issues fast
+- Better maintainable code
+- More understandable code
+- CI/CD integration
+- Regression prevention
+
+## CAP Testing
+
+### Jest Setup
+
+```javascript
+// package.json
+{
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0",
+    "@sap/cds-dk": "^7.0.0"
+  }
+}
+```
+
+### Unit Test Example
+
+```javascript
+// test/unit/catalog-service.test.js
+const cds = require('@sap/cds');
+
+describe('CatalogService', () => {
+  let srv;
+
+  beforeAll(async () => {
+    srv = await cds.connect.to('CatalogService');
+  });
+
+  afterAll(async () => {
+    await cds.disconnect();
+  });
+
+  describe('READ Books', () => {
+    it('should return all books', async () => {
+      const books = await srv.read('Books');
+      expect(books).toBeDefined();
+      expect(Array.isArray(books)).toBe(true);
+    });
+
+    it('should filter by title', async () => {
+      const books = await srv.read('Books').where({ title: 'Test Book' });
+      expect(books.length).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('CREATE Books', () => {
+    it('should create a book', async () => {
+      const book = await srv.create('Books', {
+        title: 'New Book',
+        stock: 10
+      });
+      expect(book.ID).toBeDefined();
+      expect(book.title).toBe('New Book');
+    });
+
+    it('should reject invalid data', async () => {
+      await expect(srv.create('Books', {}))
+        .rejects.toThrow();
+    });
+  });
+});
+```
+
+### Integration Test Example
+
+```javascript
+// test/integration/api.test.js
+const cds = require('@sap/cds');
+const { GET, POST, PATCH, DELETE } = cds.test(__dirname + '/..');
+
+describe('API Integration', () => {
+  it('GET /catalog/Books', async () => {
+    const { status, data } = await GET('/catalog/Books');
+    expect(status).toBe(200);
+    expect(data.value).toBeDefined();
+  });
+
+  it('POST /catalog/Books', async () => {
+    const { status, data } = await POST('/catalog/Books', {
+      title: 'Test Book',
+      stock: 5
+    });
+    expect(status).toBe(201);
+    expect(data.ID).toBeDefined();
+  });
+
+  it('GET /catalog/Books/:id', async () => {
+    const { data: created } = await POST('/catalog/Books', { title: 'Test' });
+    const { status, data } = await GET(`/catalog/Books(${created.ID})`);
+    expect(status).toBe(200);
+    expect(data.title).toBe('Test');
+  });
+});
+```
+
+## SAPUI5 Testing
+
+### QUnit Framework
+
+**Best Practice**: Write small, focused tests
+
+```javascript
+// webapp/test/unit/model/formatter.js
+sap.ui.define([
+  "my/app/model/formatter"
+], function(formatter) {
+  "use strict";
+
+  QUnit.module("formatter");
+
+  QUnit.test("formatStatus", function(assert) {
+    assert.strictEqual(
+      formatter.formatStatus("OPEN"),
+      "Open",
+      "Status formatted correctly"
+    );
+  });
+
+  QUnit.test("formatDate", function(assert) {
+    const date = new Date("2024-01-15");
+    assert.strictEqual(
+      formatter.formatDate(date),
+      "Jan 15, 2024",
+      "Date formatted correctly"
+    );
+  });
+});
+```
+
+### OPA5 Integration Tests
+
+```javascript
+// webapp/test/integration/pages/List.js
+sap.ui.define([
+  "sap/ui/test/Opa5",
+  "sap/ui/test/actions/Press"
+], function(Opa5, Press) {
+  "use strict";
+
+  Opa5.createPageObjects({
+    onTheListPage: {
+      actions: {
+        iPressOnFirstItem: function() {
+          return this.waitFor({
+            controlType: "sap.m.ObjectListItem",
+            success: function(aItems) {
+              new Press().executeOn(aItems[0]);
+            }
+          });
+        }
+      },
+      assertions: {
+        iShouldSeeTheList: function() {
+          return this.waitFor({
+            id: "list",
+            success: function() {
+              Opa5.assert.ok(true, "List is visible");
+            }
+          });
+        }
+      }
+    }
+  });
+});
+```
+
+### OPA5 Journey
+
+```javascript
+// webapp/test/integration/AllJourneys.js
+sap.ui.define([
+  "sap/ui/test/Opa5",
+  "./pages/List",
+  "./ListJourney"
+], function(Opa5) {
+  "use strict";
+
+  Opa5.extendConfig({
+    viewNamespace: "my.app.view.",
+    autoWait: true
+  });
+});
+
+// webapp/test/integration/ListJourney.js
+sap.ui.define([
+  "sap/ui/test/opaQunit"
+], function(opaTest) {
+  "use strict";
+
+  QUnit.module("List Journey");
+
+  opaTest("Should see the list", function(Given, When, Then) {
+    Given.iStartMyApp();
+    Then.onTheListPage.iShouldSeeTheList();
+    Given.iTeardownMyApp();
+  });
+
+  opaTest("Should navigate to detail", function(Given, When, Then) {
+    Given.iStartMyApp();
+    When.onTheListPage.iPressOnFirstItem();
+    Then.onTheDetailPage.iShouldSeeTheDetail();
+    Given.iTeardownMyApp();
+  });
+});
+```
+
+## ABAP Testing
+
+### ABAP Unit
+
+```abap
+CLASS ltcl_travel DEFINITION FINAL FOR TESTING
+  DURATION SHORT
+  RISK LEVEL HARMLESS.
+
+  PRIVATE SECTION.
+    CLASS-DATA: mo_environment TYPE REF TO if_cds_test_environment.
+    DATA: mo_cut TYPE REF TO zcl_travel_handler.
+
+    CLASS-METHODS class_setup.
+    CLASS-METHODS class_teardown.
+    METHODS setup.
+    METHODS test_validate_dates FOR TESTING.
+    METHODS test_calculate_total FOR TESTING.
+ENDCLASS.
+
+CLASS ltcl_travel IMPLEMENTATION.
+
+  METHOD class_setup.
+    mo_environment = cl_cds_test_environment=>create(
+      i_for_entity = 'ZI_TRAVEL'
+    ).
+  ENDMETHOD.
+
+  METHOD class_teardown.
+    mo_environment->destroy( ).
+  ENDMETHOD.
+
+  METHOD setup.
+    mo_environment->clear_doubles( ).
+    mo_cut = NEW #( ).
+  ENDMETHOD.
+
+  METHOD test_validate_dates.
+    " Given
+    DATA(lv_begin) = cl_abap_context_info=>get_system_date( ).
+    DATA(lv_end) = lv_begin + 7.
+
+    " When
+    DATA(lv_valid) = mo_cut->validate_dates(
+      iv_begin = lv_begin
+      iv_end = lv_end
+    ).
+
+    " Then
+    cl_abap_unit_assert=>assert_true( lv_valid ).
+  ENDMETHOD.
+
+  METHOD test_calculate_total.
+    " Given
+    DATA(lv_booking_fee) = CONV decfloat16( '50.00' ).
+    DATA(lv_price) = CONV decfloat16( '500.00' ).
+
+    " When
+    DATA(lv_total) = mo_cut->calculate_total(
+      iv_booking_fee = lv_booking_fee
+      iv_price = lv_price
+    ).
+
+    " Then
+    cl_abap_unit_assert=>assert_equals(
+      exp = '550.00'
+      act = lv_total
+    ).
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+### CDS Test Double Framework
+
+```abap
+" Create test doubles for CDS entities
+DATA(lo_env) = cl_cds_test_environment=>create(
+  i_for_entity = 'ZI_TRAVEL'
+).
+
+" Insert test data
+DATA: lt_travel TYPE TABLE OF ztravel.
+lt_travel = VALUE #(
+  ( travel_uuid = cl_uuid_factory=>create_uuid_c32( )
+    travel_id = '1'
+    customer_id = 'CUST001'
+    begin_date = '20240101'
+    end_date = '20240108' )
+).
+lo_env->insert_test_data( lt_travel ).
+
+" Run tests...
+
+" Clear after tests
+lo_env->clear_doubles( ).
+```
+
+## Test Automation
+
+### CI/CD Integration
+
+```yaml
+# .pipeline/config.yml
+stages:
+  Additional Unit Tests:
+    npmExecuteScripts: true
+    npmScripts:
+      - test
+
+  Integration Tests:
+    npmExecuteScripts: true
+    npmScripts:
+      - test:integration
+
+  UI Tests:
+    karmaExecuteTests: true
+```
+
+### Code Coverage
+
+```javascript
+// jest.config.js
+module.exports = {
+  collectCoverage: true,
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  }
+};
+```
+
+## Best Practices
+
+### Unit Tests
+1. Test one thing at a time
+2. Use descriptive names
+3. Follow AAA pattern (Arrange, Act, Assert)
+4. Mock external dependencies
+5. Keep tests fast
+
+### Integration Tests
+1. Test real interactions
+2. Use test data that represents production
+3. Clean up after tests
+4. Test error paths
+
+### UI Tests
+1. Test user journeys
+2. Use page objects pattern
+3. Keep tests maintainable
+4. Test accessibility
+
+## Source Documentation
+
+- Testing: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/performing-ui-usability-and-unit-tests-50a7c7d.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/performing-ui-usability-and-unit-tests-50a7c7d.md)
+- SAPUI5 Testing: [https://sapui5.hana.ondemand.com/#/topic/291c9121e6044ab381e0b51716f97f52](https://sapui5.hana.ondemand.com/#/topic/291c9121e6044ab381e0b51716f97f52)
+- CAP Testing: [https://cap.cloud.sap/docs/node.js/cds-test](https://cap.cloud.sap/docs/node.js/cds-test)

references/tools.md

@@ -0,0 +1,306 @@
+# SAP BTP Development Tools Reference
+
+## Development Environments
+
+### SAP Business Application Studio
+
+**Type**: Cloud-based IDE optimized for SAP development
+
+**Foundation**: Code-OSS (VS Code base)
+
+**Capabilities:**
+- SAP Fiori application development
+- CAP application development
+- HANA database extensions
+- Full-stack development
+- Mobile development
+
+**Dev Spaces:**
+
+| Dev Space | Purpose |
+|-----------|---------|
+| Full Stack Cloud Application | CAP, Fiori, HANA |
+| SAP Fiori | Fiori Elements, Freestyle |
+| SAP HANA Native Application | HDI containers, calculation views |
+| SAP Mobile Application | Mobile Development Kit |
+| Basic | General development |
+
+### ABAP Development Tools (ADT)
+
+**Type**: Eclipse-based IDE for ABAP development
+
+**Capabilities:**
+- ABAP Cloud development
+- RAP business objects
+- CDS view modeling
+- ABAP unit testing
+- ATC integration
+
+**Installation:**
+1. Download Eclipse IDE
+2. Install ADT from SAP update site
+3. Connect to ABAP system
+
+### SAP Build
+
+**Type**: Low-code/no-code platform
+
+**Components:**
+- **SAP Build Apps**: Drag-and-drop application creation
+- **SAP Build Process Automation**: Workflow and RPA
+- **SAP Build Work Zone**: Business sites
+
+## Administrative Tools
+
+### SAP BTP Cockpit
+
+**Purpose**: Web-based platform administration
+
+**Capabilities:**
+- Application management
+- Resource configuration
+- Security monitoring
+- Cloud application operations
+- Entitlement management
+
+### Landscape Portal
+
+**Purpose**: Partner and SaaS management (ABAP)
+
+**Capabilities:**
+- System management
+- Tenant management
+- Product lifecycle
+- Deployment pipelines
+
+## Command-Line Tools
+
+### Cloud Foundry CLI
+
+**Purpose**: Deploy and manage CF applications
+
+**Installation:**
+```bash
+# macOS
+brew install cloudfoundry/tap/cf-cli
+
+# Windows
+choco install cloudfoundry-cli
+
+# Linux
+wget -q -O - [https://packages.cloudfoundry.org/debian/cli.cloudfoundry.org.key](https://packages.cloudfoundry.org/debian/cli.cloudfoundry.org.key) | sudo apt-key add -
+echo "deb [https://packages.cloudfoundry.org/debian](https://packages.cloudfoundry.org/debian) stable main" | sudo tee /etc/apt/sources.list.d/cloudfoundry-cli.list
+sudo apt update && sudo apt install cf-cli
+```
+
+**Common Commands:**
+```bash
+# Login
+cf login -a [https://api.cf.eu10.hana.ondemand.com](https://api.cf.eu10.hana.ondemand.com)
+
+# Deploy
+cf push my-app
+
+# View apps
+cf apps
+
+# View services
+cf services
+
+# Scale
+cf scale my-app -i 3
+
+# Logs
+cf logs my-app --recent
+```
+
+### CDS CLI
+
+**Purpose**: CAP development commands
+
+**Installation:**
+```bash
+# Install latest version (recommended for new projects)
+npm install -g @sap/cds-dk@latest
+
+# Or pin to specific version for reproducibility
+npm install -g @sap/cds-dk@8.0.0
+```
+
+> **Version Strategy**: Use `@latest` for development to get newest features. For CI/CD pipelines and team consistency, pin to a specific version in your project's `package.json` devDependencies.
+
+**Common Commands:**
+```bash
+cds init my-project        # Create project
+cds add hana               # Add HANA support
+cds add xsuaa              # Add authentication
+cds watch                  # Run with live reload
+cds build                  # Build for deployment
+cds deploy                 # Deploy to HANA
+cds compile                # Compile CDS models
+```
+
+### MTA Build Tool (mbt)
+
+**Purpose**: Build multitarget applications
+
+**Installation:**
+```bash
+npm install -g mbt
+```
+
+**Commands:**
+```bash
+mbt build                  # Build MTA archive
+mbt build -t ./            # Build to current directory
+```
+
+### CF MTA Plugin
+
+**Purpose**: Deploy MTA archives
+
+**Installation:**
+```bash
+cf install-plugin multiapps
+```
+
+**Commands:**
+```bash
+cf deploy my-app.mtar      # Deploy MTA
+cf mtas                    # List deployed MTAs
+cf undeploy my-app         # Undeploy MTA
+```
+
+## Kubernetes Tools
+
+### kubectl
+
+**Purpose**: Kubernetes cluster management
+
+**Commands:**
+```bash
+kubectl get pods           # List pods
+kubectl logs my-pod        # View logs
+kubectl describe pod       # Pod details
+kubectl apply -f file.yaml # Apply configuration
+```
+
+### kubelogin
+
+**Purpose**: OIDC authentication for kubectl
+
+### Helm
+
+**Purpose**: Kubernetes package manager
+
+**Commands:**
+```bash
+helm install my-app ./chart      # Install chart
+helm upgrade my-app ./chart      # Upgrade release
+helm list                        # List releases
+helm uninstall my-app            # Uninstall
+```
+
+### Paketo (Pack)
+
+**Purpose**: Cloud Native Buildpacks for container images
+
+**Commands:**
+```bash
+pack build my-image --builder paketobuildpacks/builder:base
+```
+
+### Docker Desktop
+
+**Purpose**: Local container development
+
+## Infrastructure Tools
+
+### Terraform Provider for SAP BTP
+
+**Purpose**: Infrastructure as code for SAP BTP
+
+**Configuration:**
+```hcl
+terraform {
+  required_providers {
+    btp = {
+      source = "SAP/btp"
+    }
+  }
+}
+
+provider "btp" {
+  globalaccount = var.globalaccount
+}
+
+resource "btp_subaccount" "my_subaccount" {
+  name      = "my-subaccount"
+  region    = "eu10"
+  subdomain = "my-subdomain"
+}
+```
+
+### Cloud Connector
+
+**Purpose**: Secure on-premise connectivity
+
+**Features:**
+- Reverse proxy operation
+- Access control
+- High availability
+- Audit logging
+
+## Development Libraries
+
+### SAP Cloud SDK
+
+**Purpose**: Abstraction layer for enterprise development
+
+**Languages**: Java, JavaScript/TypeScript
+
+**Features:**
+- Logging
+- Multitenancy
+- Connectivity
+- OData/OpenAPI clients
+
+**Installation (Node.js):**
+```bash
+npm install @sap-cloud-sdk/core
+npm install @sap-cloud-sdk/odata-v2-generator
+```
+
+**Example:**
+```javascript
+const { BusinessPartner } = require('@sap/cloud-sdk-vdm-business-partner-service');
+
+const partners = await BusinessPartner.requestBuilder()
+  .getAll()
+  .execute({ destinationName: 'S4HANA' });
+```
+
+## SAP Fiori Tools
+
+### Capabilities
+
+| Tool | Purpose |
+|------|---------|
+| Application Wizard | Generate Fiori apps |
+| Service Modeler | Design OData services |
+| Page Editor | Configure Fiori Elements pages |
+| Guided Development | Step-by-step development |
+| XML Editor | Edit Fiori Elements views |
+
+### Installation (VS Code)
+
+Search for "SAP Fiori tools" in VS Code extensions.
+
+## Service-Specific Tools
+
+Available through SAP Discovery Center for individual services.
+
+## Source Documentation
+
+- Tools Available: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tools-available-for-sap-btp-multi-cloud-foundation-7f95cfa.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tools-available-for-sap-btp-multi-cloud-foundation-7f95cfa.md)
+- SAP Discovery Center: [https://discovery-center.cloud.sap/](https://discovery-center.cloud.sap/)

references/tutorials.md

@@ -0,0 +1,257 @@
+# SAP BTP Tutorials Reference
+
+## Overview
+
+SAP BTP provides structured learning paths through missions and tutorials, covering CAP and ABAP Cloud development scenarios.
+
+## Account Options
+
+### Free Tier for SAP BTP
+
+**Best for**: Productive projects
+
+- 30+ free-tier services
+- Upgrade capability to paid plans
+- Available under BTPEA, CPEA, Pay-As-You-Go
+- One free plan per runtime (CF/Kyma)
+
+### SAP BTP Trial
+
+**Best for**: Learning and experimentation
+
+- 90-day trial period
+- 30+ trial services
+- Instant access
+- Learning materials included
+
+## CAP Learning Path
+
+### Mission 1: Full-Stack CAP Application (Starter)
+
+**Sample Application**: Incident Management
+
+**Modules:**
+
+| Module | Topics |
+|--------|--------|
+| Core Development | Environment setup, CAP basics, Fiori Elements UI, custom logic, local launchpad, authorization, testing |
+| Cloud Foundry Deployment | CF deployment, SAP Build Work Zone, CI/CD |
+| Kyma Deployment | Kyma deployment, Work Zone, CI/CD |
+
+**Discovery Center**: Mission 4033/4432
+
+### Mission 2: Side-by-Side Extension
+
+**Sample Application**: Incident Management + S/4HANA
+
+**Tracks:**
+
+| Track | Runtime | Backend |
+|-------|---------|---------|
+| Remote Service - CF | Cloud Foundry | Mock Server |
+| Remote Service - CF | Cloud Foundry | S/4HANA Cloud |
+| Remote Service - Kyma | Kyma | Mock Server |
+| Remote Service - Kyma | Kyma | S/4HANA Cloud |
+| Eventing - CF | Cloud Foundry | Mock/S/4HANA |
+| Eventing - Kyma | Kyma | Mock/S/4HANA |
+
+**Prerequisites**: Complete remote service before eventing
+
+**Discovery Center**: Mission 3999
+
+### Mission 3: Enterprise-Grade CAP Application
+
+**Features:**
+- Change tracking
+- Audit logging
+- Attachment uploads
+
+**Sample Application**: Incident Management (enhanced)
+
+**Discovery Center**: Mission 4364
+
+### Mission 4: Multitenant CAP Application
+
+**Sample Application**: Incident Management (SaaS)
+
+**Entry Point Options:**
+
+| Approach | Consumer Requirements | Site Management |
+|----------|----------------------|-----------------|
+| Central | SAP Build Work Zone instance | Consumer managed |
+| Local | None | Provider managed |
+
+**Key Features:**
+- Tenant isolation
+- Subscription lifecycle
+- Key user extensibility
+
+**Discovery Center**: Mission 4497
+
+### Mission 5: Observability in CAP Application
+
+**Tool**: SAP Cloud Logging
+
+**Capabilities:**
+- Logs
+- Metrics
+- Traces
+
+**Discovery Center**: Mission 4432/4718
+
+## ABAP Learning Path
+
+### RAP100 Basics (Transactional)
+
+**Sample Application**: Flight Reference Scenario
+
+**Tutorials:**
+
+| Tutorial | Topics |
+|----------|--------|
+| Understanding RAP | Fundamentals, architecture |
+| Database Tables | Table creation, data elements |
+| UI Service Generation | Automatic CDS/RAP generation |
+| Data Model Enhancement | Associations, annotations |
+| OData Streams | Large object handling |
+| Business Object Behavior | Numbering, determinations, validations |
+| Fiori App Deployment | UI deployment, testing |
+| Fiori Launchpad | Integration, tiles |
+
+### RAP100 Intermediate
+
+**Tutorials:**
+
+| Tutorial | Topics |
+|----------|--------|
+| Instance Actions | Custom actions on entities |
+| Factory Actions | Create with copy |
+| Dynamic Feature Control | Conditional UI elements |
+| ABAP Unit Testing | Test class creation |
+
+### RAP120 (AI-Assisted)
+
+**Tool**: SAP Joule
+
+**Capabilities:**
+- Predictive code completion
+- ABAP Cloud Generator
+- Unit test generation
+
+**GitHub**: RAP120 sample project
+
+### Analytical Scenario
+
+**Tutorials:**
+
+| Level | Tutorial |
+|-------|----------|
+| Beginner | Develop and Consume Queries on SAP Analytics Cloud |
+| Intermediate | Queries Based on Booking Supplement |
+
+**Integration**: SAP Analytics Cloud with InA-enabled CDS
+
+### Certifications
+
+| Certification | Focus |
+|---------------|-------|
+| SAP Certified Associate - Back-End Developer - ABAP Cloud | RAP, CDS, ABAP Cloud |
+
+## Partner Tutorials
+
+### Poetry Slam Manager (CAP)
+
+**Type**: Reference application for multitenant CAP SaaS
+
+**GitHub**: [https://github.com/SAP-samples/partner-reference-application/](https://github.com/SAP-samples/partner-reference-application/)
+
+**Tutorial Coverage:**
+1. Core application development (business models, logic)
+2. Enhancement to multitenant (multi-customer) solutions
+3. ERP backend integration (S/4HANA Cloud, Business One, Business ByDesign)
+4. Feature expansion
+5. Application extension
+
+**Key Topics:**
+- Full-stack CAP development
+- ERP-agnostic design
+- Cost optimization
+- Subscription lifecycle
+
+**Bill of Materials**: [https://github.com/SAP-samples/partner-reference-application/blob/main/Tutorials/01-BillOfMaterials.md](https://github.com/SAP-samples/partner-reference-application/blob/main/Tutorials/01-BillOfMaterials.md)
+
+### Music Festival Manager (ABAP)
+
+**Type**: Reference application for multitenant ABAP SaaS
+
+**GitHub**: Partner Reference Application on GitHub
+
+**Tutorial Coverage:**
+1. **Core Application Development**: Business models, logic, UI, authentication, role-based authorization
+2. **Deployment & Provisioning**: Building and deploying to consumers
+3. **SAP S/4HANA Cloud Integration**: Connecting with enterprise systems
+4. **Feature Enhancement**: Expanding application capabilities
+
+**Key Topics:**
+- Full-stack ABAP Cloud development using RAP
+- Scalable multitenant architecture
+- SAP BTP Developer's Guide best practices
+
+### Partner Reference Application Extension
+
+**Type**: Customer-specific extension example
+
+**GitHub**: [https://github.com/SAP-samples/partner-reference-application-extension](https://github.com/SAP-samples/partner-reference-application-extension)
+
+**Topics:**
+- Enhanced catering management capabilities
+- Tenant-specific configurations
+- Key user extensibility
+- Base application integration
+
+## Learning Resources
+
+### SAP Learning Journeys
+
+| Journey | Focus |
+|---------|-------|
+| Practicing Clean Core Extensibility for SAP S/4HANA Cloud | Extensions |
+| Acquiring Core ABAP Skills | ABAP fundamentals |
+
+### Additional Resources
+
+| Resource | URL |
+|----------|-----|
+| SAP Developers | [https://developers.sap.com/](https://developers.sap.com/) |
+| SAP Learning | [https://learning.sap.com/](https://learning.sap.com/) |
+| SAP Community | [https://community.sap.com/](https://community.sap.com/) |
+| SAP Discovery Center | [https://discovery-center.cloud.sap/](https://discovery-center.cloud.sap/) |
+
+## Prerequisites Management
+
+### Entitlements
+
+Before starting missions:
+1. Open BTP Cockpit
+2. Navigate to Entitlements
+3. Configure quotas for services
+4. Assign to subaccount
+
+### Common Services Required
+
+| Service | Plan | Purpose |
+|---------|------|---------|
+| SAP HANA Cloud | hana | Database |
+| Cloud Foundry Runtime | MEMORY | Application runtime |
+| SAP Build Work Zone | standard | Launchpad |
+| Continuous Integration & Delivery | default | CI/CD |
+
+## Source Documentation
+
+- CAP Tutorials: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tutorials-for-sap-cloud-application-programming-model-eb7420a.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tutorials-for-sap-cloud-application-programming-model-eb7420a.md)
+- ABAP Tutorials: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tutorials-for-abap-cloud-fd87aaa.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/tutorials-for-abap-cloud-fd87aaa.md)
+- Starter Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/starter-mission-develop-a-full-stack-cap-application-ebd19b5.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/starter-mission-develop-a-full-stack-cap-application-ebd19b5.md)
+- Extension Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-a-side-by-side-cap-based-extension-application-2289e25.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-a-side-by-side-cap-based-extension-application-2289e25.md)
+- Multitenant Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-a-multitenant-cap-application-6d2cbe9.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-a-multitenant-cap-application-6d2cbe9.md)
+- Enterprise Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-an-enterprise-grade-cap-application-b5be786.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-develop-an-enterprise-grade-cap-application-b5be786.md)
+- Observability Mission: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-implement-observability-in-a-full-stack-cap-application-c5636db.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/mission-implement-observability-in-a-full-stack-cap-application-c5636db.md)

references/ux-design.md

@@ -0,0 +1,270 @@
+# SAP BTP UX Design Reference
+
+## Overview
+
+SAP BTP applications require consistent, compliant user experiences using the SAP Fiori design language. Three main approaches are recommended for UI development.
+
+## User Experience Dimensions
+
+### Five Usability Factors
+
+| Factor | Description |
+|--------|-------------|
+| Effectiveness | Accomplishing intended tasks |
+| Efficiency | Minimizing effort required |
+| Ease of learning | Intuitiveness for new users |
+| Error tolerance | Handling mistakes gracefully |
+| Satisfaction | Positive user perception |
+
+### Consistency
+
+Consistency contributes to ease of learning and efficiency. Follow SAP Fiori Design Guidelines to maintain alignment with standard SAP applications.
+
+## UI Development Approaches
+
+### 1. SAP Fiori Elements
+
+**Description**: Framework on top of SAPUI5 with predefined templates based on OData services
+
+**Best For**: Standard business applications
+
+#### Floorplans
+
+| Floorplan | Use Case |
+|-----------|----------|
+| List Report | Data browsing with filters |
+| Object Page | Detail view with sections |
+| Overview Page | KPIs and quick actions |
+| Worklist | Task-oriented lists |
+| Analytical List Page | Analytics with filters |
+
+#### Building Blocks
+
+Reusable UI components:
+- Data visualization
+- Form entry
+- Value helps
+- Tables
+- Charts
+
+#### Benefits
+- Rapid development
+- Consistent UX
+- Automatic compliance
+- Responsive design
+
+### 2. Flexible Programming Model
+
+**Description**: Extend SAP Fiori Elements with custom logic
+
+**Best For**: Applications needing selective customization
+
+#### Extension Points
+- Custom columns
+- Custom actions
+- Custom sections
+- Custom fragments
+
+#### Custom Pages
+Leverage Fiori Elements base with:
+- Building blocks
+- Routing
+- State management
+
+### 3. Freestyle SAPUI5
+
+**Description**: Full UI control using SAPUI5 framework
+
+**Best For**: Highly customized interfaces
+
+**Considerations**:
+- Greater development effort
+- Manual compliance implementation
+- Full flexibility
+
+## SAP Fiori Tools
+
+| Tool | Purpose |
+|------|---------|
+| Application Wizard | Generate Fiori apps from templates |
+| Service Modeler | Design OData services visually |
+| Page Editor | Configure Fiori Elements pages |
+| XML Editor | Edit view definitions |
+| Guided Development | Step-by-step feature addition |
+
+## Compliance Standards
+
+### Automatic Inheritance
+
+> **Note**: Automatic compliance applies specifically when using **SAP Fiori Elements** with recommended patterns, **OData V4** services with proper annotations, and **internationalization (i18n)** setup. Custom or Freestyle SAPUI5 applications require manual compliance verification.
+
+**Prerequisites for automatic compliance:**
+1. Use SAP Fiori Elements floorplans
+2. Expose OData V4 services with proper UI annotations
+3. Enable internationalization (i18n) for all user-facing text
+4. Follow SAP Fiori design guidelines for customizations
+
+| Standard | Coverage | Requirement |
+|----------|----------|-------------|
+| Accessibility (WCAG 2.2) | Automatic | Fiori Elements + proper labels |
+| SAP Fiori Design Guidelines | Automatic | Standard floorplans |
+| Responsive Design | Automatic | Fiori Elements controls |
+| Performance Optimization | Automatic | OData V4 batching |
+| Security Protections | Automatic | XSUAA + CSRF tokens |
+
+### Accessibility Requirements
+
+```xml
+<!-- Example: Accessible form -->
+<Label text="Name" labelFor="nameInput"/>
+<Input id="nameInput" value="{/name}"
+       ariaLabelledBy="nameLabel"/>
+```
+
+### Internationalization
+
+```javascript
+// i18n/i18n.properties
+welcomeMessage=Welcome to the Application
+saveButton=Save
+cancelButton=Cancel
+
+// i18n/i18n_de.properties
+welcomeMessage=Willkommen in der Anwendung
+saveButton=Speichern
+cancelButton=Abbrechen
+```
+
+## Design Methodology
+
+### Iterative Approach
+
+**Motto**: "Fail fast, fail early"
+
+**Process**:
+1. Sketch solutions
+2. Gather feedback
+3. Refine designs
+4. Repeat until needs met
+
+### User Research
+
+**Methods**:
+- Stakeholder interviews
+- Contextual inquiry
+- Usability testing
+- A/B testing
+
+**Resources**: SAP User Research Resources guide
+
+## Fiori Elements Configuration
+
+### annotations.cds
+
+```cds
+using CatalogService as service from '../srv/catalog-service';
+
+annotate service.Books with @(
+  UI: {
+    SelectionFields: [title, author_ID],
+    LineItem: [
+      { Value: title },
+      { Value: author.name, Label: 'Author' },
+      { Value: stock },
+      { Value: price }
+    ],
+    HeaderInfo: {
+      TypeName: 'Book',
+      TypeNamePlural: 'Books',
+      Title: { Value: title },
+      Description: { Value: author.name }
+    },
+    Facets: [
+      {
+        $Type: 'UI.ReferenceFacet',
+        Label: 'General Information',
+        Target: '@UI.FieldGroup#GeneralInfo'
+      }
+    ],
+    FieldGroup#GeneralInfo: {
+      Data: [
+        { Value: title },
+        { Value: author_ID },
+        { Value: stock },
+        { Value: price }
+      ]
+    }
+  }
+);
+```
+
+### manifest.json Routing
+
+```json
+{
+  "sap.ui5": {
+    "routing": {
+      "routes": [
+        {
+          "name": "BooksList",
+          "pattern": ":?query:",
+          "target": "BooksList"
+        },
+        {
+          "name": "BooksDetail",
+          "pattern": "Books({key}):?query:",
+          "target": "BooksDetail"
+        }
+      ],
+      "targets": {
+        "BooksList": {
+          "type": "Component",
+          "id": "BooksList",
+          "name": "sap.fe.templates.ListReport"
+        },
+        "BooksDetail": {
+          "type": "Component",
+          "id": "BooksDetail",
+          "name": "sap.fe.templates.ObjectPage"
+        }
+      }
+    }
+  }
+}
+```
+
+## Responsive Design
+
+### Breakpoints
+
+| Size | Width | Typical Device |
+|------|-------|----------------|
+| Phone | < 600px | Mobile |
+| Tablet | 600-1024px | Tablet |
+| Desktop | > 1024px | Desktop |
+
+### Responsive Handling
+
+```xml
+<FlexBox direction="Column"
+         class="sapUiResponsiveMargin">
+  <Table growing="true"
+         growingThreshold="20"
+         mode="{= ${device>/system/phone} ? 'None' : 'SingleSelectMaster'}">
+  </Table>
+</FlexBox>
+```
+
+## Resources
+
+| Resource | URL |
+|----------|-----|
+| SAP Fiori Design Guidelines | [https://experience.sap.com/fiori-design-web/](https://experience.sap.com/fiori-design-web/) |
+| Accessibility Guidelines | [https://experience.sap.com/fiori-design-web/accessibility/](https://experience.sap.com/fiori-design-web/accessibility/) |
+| SAPUI5 Demo Kit | [https://sapui5.hana.ondemand.com/](https://sapui5.hana.ondemand.com/) |
+| Fiori Tools | SAP Business Application Studio |
+
+## Source Documentation
+
+- UX Design: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/user-experience-design-323bd93.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/user-experience-design-323bd93.md)
+- UX Compliance: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/ux-design-and-product-compliance-standards-91e4468.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/ux-design-and-product-compliance-standards-91e4468.md)

references/whats-new.md

@@ -0,0 +1,75 @@
+# SAP BTP What's New Reference
+
+## Overview
+
+This document tracks updates to the SAP BTP Developer's Guide organized chronologically.
+
+## 2025 Updates
+
+### November 2025
+
+| Date | Update |
+|------|--------|
+| November 5, 2025 | New tutorials for partners developing ABAP-based applications introduce the **Music Festival Manager reference app** for scalable multitenant SaaS using RAP |
+| November 3, 2025 | End-to-end observability guidance added combining SAP Cloud ALM (central) with SAP Cloud Logging (local) using OpenTelemetry |
+
+### October 2025
+
+| Date | Update |
+|------|--------|
+| October 31, 2025 | New SAP HANA Cloud content emphasizing TCO reduction best practices across ABAP, Kyma, and Cloud Foundry |
+| October 30, 2025 | ABAP Cloud content enhanced with specific recommendations and hands-on materials |
+| October 17, 2025 | New page for UX design and product compliance standards across all BTP environments |
+| October 3, 2025 | Partner information expanded with TCO calculations for multitenant SaaS plus additional tutorials |
+
+### September 2025
+
+| Date | Update |
+|------|--------|
+| September 25, 2025 | Security information integrated throughout development phases (exploration → production) |
+| September 15, 2025 | Guide restructured with new sections on runtime benefits (CF/Kyma with CAP, ABAP Cloud) |
+| September 1, 2025 | Major restructuring into four main sections: technology, runtime benefits, CAP, ABAP Cloud |
+
+### Earlier 2025
+
+| Date | Update |
+|------|--------|
+| June 2, 2025 | New CI/CD chapter introducing fundamentals and SAP solutions |
+| April 25, 2025 | New page for remote system connectivity approaches |
+| January 3, 2025 | Partner reference application for multitenant SaaS development |
+
+## 2024 Notable Additions
+
+- Guide restructured to align with design-led development processes
+- New missions for enterprise-grade and multitenant CAP applications
+- Observability implementation guidance added
+- Expanded tutorials for Cloud Foundry and Kyma runtimes
+
+## Key Feature Introductions by Date
+
+### Partner Development
+- **November 2025**: Music Festival Manager (ABAP RAP)
+- **October 2025**: TCO Calculator for SaaS
+- **January 2025**: Poetry Slam Manager (CAP)
+
+### Observability
+- **November 2025**: OpenTelemetry integration
+- **2024**: SAP Cloud ALM integration
+
+### Security
+- **September 2025**: Phase-integrated security guidance
+
+### CI/CD
+- **June 2025**: CI/CD fundamentals chapter
+
+### Connectivity
+- **April 2025**: Remote system connectivity guide
+
+## Tracking Updates
+
+**Source**: [https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/what-s-new-for-sap-btp-developer-s-guide-7cf7a39.md](https://github.com/SAP-docs/btp-developer-guide/blob/main/docs/what-s-new-for-sap-btp-developer-s-guide-7cf7a39.md)
+
+To check for new updates:
+1. Visit the source documentation
+2. Compare with dates listed here
+3. Update this reference file accordingly