Document Purpose: Feasibility analysis and architectural options for integrating GLOMIDCO XBRL processor into SAP CPI as an extension
Author: Technical Analysis
Date: January 2026
Target Audience: SAP CPI architects, XBRL processor developers, enterprise integration teams
Question: Can GLOMIDCO XBRL processor be integrated into SAP Cloud Platform Integration (CPI) as an expansion/extension?
Answer: YES - SAP CPI provides multiple extensibility mechanisms that would allow GLOMIDCO XBRL processor integration.
Recommended Approach: Hybrid architecture with GLOMIDCO as both:
Feasibility: ⭐⭐⭐⭐ (High) - Technically feasible with good business case
SAP Cloud Platform Integration (CPI) - now part of SAP Integration Suite:
SAP Integration Suite Components:
├─ Cloud Integration (CPI) - Integration flows
├─ API Management - API gateway
├─ Open Connectors - Pre-built connectors
├─ Integration Advisor - Mapping recommendations
└─ Trading Partner Management - B2B integration
Core Capabilities:
Technical Foundation:
Technology Stack:
├─ Runtime: Apache Camel (Java-based)
├─ Platform: Cloud Foundry / SAP BTP
├─ Languages: Groovy, JavaScript, Java
├─ Standards: OASIS, W3C, IETF
└─ Protocols: HTTP, HTTPS, SFTP, AMQP, etc.
SAP CPI offers multiple extension points:
Custom Adapter Framework:
├─ Implement adapter interface
├─ Package as integration flow
├─ Deploy to CPI tenant
└─ Use in integration flows
Examples: Custom XBRL adapter
Groovy Scripting:
├─ Inline scripts in integration flows
├─ Access to message payload
├─ Access to external libraries (limited)
├─ Good for: Lightweight transformations
└─ Limitation: Memory and CPU constraints
Custom JAR Libraries:
├─ Upload JAR to CPI
├─ Reference from Groovy scripts
├─ Full Java capabilities
├─ Good for: Complex logic
└─ Limitation: Library size, dependencies
External Service Integration:
├─ Deploy service externally
├─ Call via HTTP adapter
├─ Loose coupling
├─ Good for: Heavy processing
└─ Benefit: Independent scaling
Pre-built Integration Flows:
├─ Package integration flows
├─ Deploy as content package
├─ Configure parameters
├─ Good for: Reusable patterns
└─ Example: "XBRL to SAP ERP" template
Content Packages:
├─ Pre-built mappings
├─ Integration scenarios
├─ Documentation
├─ Configuration guides
└─ Example: "XBRL Regulatory Reporting Package"
Runtime Environment:
SAP CPI Runtime:
├─ Container: Cloud Foundry application
├─ Memory: 2-8 GB per worker node
├─ CPU: Shared resources
├─ Storage: Ephemeral (no persistent local storage)
├─ Network: Outbound HTTPS allowed
└─ Timeout: 5 minutes per message (default)
Key Constraints:
Limitations:
├─ Message size: 40 MB (default limit)
├─ Processing time: 5 minutes (configurable up to 60 min)
├─ Memory per flow: Shared across tenant
├─ JAR size: Reasonable limits (50-100 MB)
├─ Dependencies: Must be explicitly uploaded
└─ No file system persistence
Implications for XBRL:
Considerations:
├─ Large taxonomies: May exceed memory limits
├─ Complex transformations: May timeout
├─ Multiple concurrent flows: Resource contention
└─ Large XBRL instances: May exceed size limits
Architecture:
┌─────────────────────────────────────────┐
│ SAP CPI Integration Flow │
│ ┌───────────────────────────────────┐ │
│ │ Receive Message (e.g., iDoc) │ │
│ └───────────────┬───────────────────┘ │
│ │ │
│ ┌───────────────▼───────────────────┐ │
│ │ Groovy Script │ │
│ │ ┌─────────────────────────────┐ │ │
│ │ │ GLOMIDCO XBRL Core JAR │ │ │
│ │ │ - Lightweight processing │ │ │
│ │ │ - Basic validations │ │ │
│ │ │ - Simple transformations │ │ │
│ │ └─────────────────────────────┘ │ │
│ └───────────────┬───────────────────┘ │
│ │ │
│ ┌───────────────▼───────────────────┐ │
│ │ Send XBRL Instance │ │
│ └───────────────────────────────────┘ │
└─────────────────────────────────────────┘
What to Include in JAR:
GLOMIDCO-XBRL-Lite.jar (~20-30 MB):
├─ Core XBRL 2.1 parser
├─ Instance validation (basic)
├─ Taxonomy loading (entry points only)
├─ Concept lookup
├─ Label resolution
├─ Simple transformations
├─ Output generation (XML, JSON)
└─ Minimal dependencies (pre-bundled)
Excluded (too heavy):
├─ Formula processing (Saxon dependency)
├─ Table Linkbase (complex)
├─ Full taxonomy trees
└─ Design-time features
Groovy Script Example:
import com.glomidco.xbrl.lite.*
def Message processData(Message message) {
def body = message.getBody(String.class)
// Initialize XBRL processor
def processor = new XBRLProcessor()
// Load taxonomy (from cache or remote)
def taxonomy = processor.loadTaxonomy("sbr-rj-2024")
// Parse input data
def inputData = parseInput(body)
// Create XBRL instance
def instance = processor.createInstance(taxonomy)
instance.addFacts(inputData)
// Validate
def validationResult = instance.validate()
if (!validationResult.isValid()) {
throw new Exception("Validation failed: " + validationResult.getErrors())
}
// Generate XBRL output
def xbrlOutput = instance.toXML()
message.setBody(xbrlOutput)
return message
}
Pros:
Cons:
Use Cases:
Ideal For:
├─ Simple XBRL generation (ERP → XBRL)
├─ Basic validation
├─ XBRL → JSON transformation
├─ Concept lookups
└─ Label resolution
Not Suitable For:
├─ Complex regulatory reporting (COREP/FINREP)
├─ Formula-heavy taxonomies
├─ Table Linkbase processing
├─ Large instance files (>10 MB)
└─ High-volume concurrent processing
Architecture:
┌─────────────────────────────────────────┐
│ SAP CPI Integration Flow │
│ ┌───────────────────────────────────┐ │
│ │ Receive Message │ │
│ └───────────────┬───────────────────┘ │
│ │ │
│ ┌───────────────▼───────────────────┐ │
│ │ HTTP Adapter │ │
│ │ POST /xbrl/process │ │
│ └───────────────┬───────────────────┘ │
└──────────────────┼───────────────────────┘
│
│ HTTPS
│
┌──────────────────▼───────────────────────┐
│ GLOMIDCO XBRL Microservice │
│ (External, independently deployed) │
│ ┌────────────────────────────────────┐ │
│ │ REST API │ │
│ │ - /xbrl/validate │ │
│ │ - /xbrl/transform │ │
│ │ - /xbrl/generate │ │
│ │ - /taxonomy/load │ │
│ └────────────────────────────────────┘ │
│ ┌────────────────────────────────────┐ │
│ │ GLOMIDCO Full Processor │ │
│ │ - Full XBRL 2.1 support │ │
│ │ - Dimensions, Formula │ │
│ │ - Table Linkbase │ │
│ │ - Saxon integration │ │
│ │ - Full validation │ │
│ └────────────────────────────────────┘ │
└──────────────────────────────────────────┘
Microservice Deployment:
Deployment Options:
├─ SAP BTP (Cloud Foundry)
├─ Kubernetes (any cloud)
├─ Docker (on-premise)
└─ Serverless (AWS Lambda, Azure Functions)
Resources:
├─ Memory: 4-16 GB (dedicated)
├─ CPU: 2-8 cores
├─ Storage: Persistent (taxonomies)
├─ Scaling: Horizontal (multiple instances)
└─ Load Balancer: Built-in
API Design:
POST /api/v1/xbrl/process
{
"operation": "generate",
"taxonomy": "sbr-rj-2024",
"entryPoint": "full",
"inputFormat": "json",
"outputFormat": "xbrl",
"data": {
"facts": [
{"concept": "Assets", "value": 1000000, "context": "..."}
]
},
"validation": {
"enabled": true,
"includeFormulas": true
}
}
Response:
{
"status": "success",
"processingTime": 2.3,
"output": {
"format": "xbrl",
"content": "<xbrl>...</xbrl>",
"size": 125000
},
"validation": {
"isValid": true,
"errors": [],
"warnings": []
}
}
CPI Integration Flow (HTTP Call):
<!-- Simplified CPI integration flow -->
<integration-flow>
<start>
<timer expression="0 0 2 * * ?"/> <!-- Daily at 2 AM -->
</start>
<content-modifier>
<prepare-xbrl-request/>
</content-modifier>
<http-adapter>
<url>https://xbrl-service.company.com/api/v1/xbrl/process</url>
<method>POST</method>
<authentication>OAuth2</authentication>
</http-adapter>
<content-modifier>
<extract-xbrl-response/>
</content-modifier>
<router>
<when condition="${property.validationStatus} = 'success'">
<sftp-send destination="/xbrl/output/"/>
</when>
<otherwise>
<mail-send to="admin@company.com" subject="XBRL Processing Failed"/>
</otherwise>
</router>
</integration-flow>
Pros:
Cons:
Use Cases:
Ideal For:
├─ Complex COREP/FINREP processing
├─ Formula-heavy taxonomies (Dutch SBR)
├─ Table Linkbase rendering
├─ Large XBRL instances (>40 MB)
├─ High-volume batch processing
├─ Multiple concurrent requests
└─ Full validation requirements
Benefits:
├─ Horizontal scaling (multiple instances)
├─ Independent release cycles
├─ Dedicated resources
└─ Full feature set
Architecture:
┌─────────────────────────────────────────────────────────────┐
│ SAP CPI Integration Flow │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ Receive Message │ │
│ └────────────────────┬──────────────────────────────────┘ │
│ │ │
│ ┌────────────────────▼──────────────────────────────────┐ │
│ │ Decision: Simple or Complex? │ │
│ │ (Message size, taxonomy, operations) │ │
│ └───────┬─────────────────────────────┬─────────────────┘ │
│ │ │ │
│ SIMPLE │ │ COMPLEX │
│ │ │ │
│ ┌───────▼──────────┐ ┌───────────▼─────────────────┐ │
│ │ Groovy Script │ │ HTTP → External Service │ │
│ │ (Embedded JAR) │ │ (Full GLOMIDCO) │ │
│ │ - Fast │ │ - Full features │ │
│ │ - In-process │ │ - Heavy processing │ │
│ └───────┬──────────┘ └───────────┬─────────────────┘ │
│ │ │ │
│ ┌───────▼─────────────────────────────▼─────────────────┐ │
│ │ Send XBRL Output │ │
│ └───────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Decision Logic:
def Message routeMessage(Message message) {
def body = message.getBody(String.class)
def size = body.length()
def taxonomy = message.getProperty("taxonomy")
def operation = message.getProperty("operation")
// Decision criteria
boolean useEmbedded = (
size < 1_000_000 && // < 1 MB
!taxonomy.contains("DNB") && // Not banking
!operation.contains("formula") && // No formulas
!operation.contains("table") // No tables
)
if (useEmbedded) {
message.setProperty("route", "embedded")
} else {
message.setProperty("route", "external")
}
return message
}
Routing Table:
Use Case → Route
─────────────────────────────────────────────────────
Simple transformation → Embedded JAR
Concept lookup → Embedded JAR
Label resolution → Embedded JAR
Basic validation (no Formula) → Embedded JAR
Small instances (<1 MB) → Embedded JAR
Formula processing → External Service
Table Linkbase → External Service
Large instances (>1 MB) → External Service
COREP/FINREP → External Service
Complex validations → External Service
Batch processing (100+ files) → External Service
Pros:
Cons:
Build Configuration:
<!-- Maven pom.xml for GLOMIDCO-XBRL-Lite -->
<project>
<groupId>com.glomidco</groupId>
<artifactId>glomidco-xbrl-lite</artifactId>
<version>1.0.0</version>
<dependencies>
<!-- Minimal dependencies -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!-- Exclude heavy dependencies -->
<!-- NO Saxon (too large) -->
<!-- NO Table Linkbase support -->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
<!-- Create fat JAR with all dependencies -->
<createDependencyReducedPom>false</createDependencyReducedPom>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.glomidco.xbrl.lite.Processor</mainClass>
</transformer>
</transformers>
</configuration>
</plugin>
</plugins>
</build>
</project>
CPI Deployment:
1. Build JAR:
mvn clean package
2. Upload to CPI:
- Go to CPI → Operations → Manage Security Material
- Upload JAR: glomidco-xbrl-lite-1.0.0.jar
3. Reference in Groovy Script:
@Grab(group='com.glomidco', module='glomidco-xbrl-lite', version='1.0.0')
import com.glomidco.xbrl.lite.*
4. Test in integration flow
Technology Stack:
Microservice Stack:
├─ Framework: Spring Boot 3.x
├─ API: REST (Spring MVC)
├─ Documentation: OpenAPI 3.0 / Swagger
├─ Security: OAuth2 / JWT
├─ Monitoring: Prometheus + Grafana
├─ Logging: ELK stack
├─ Container: Docker
└─ Orchestration: Kubernetes
GLOMIDCO Components:
├─ Core: Full GLOMIDCO processor
├─ Saxon: For Formula processing
├─ Cache: Redis (taxonomy caching)
├─ Storage: S3/Azure Blob (instance files)
└─ Queue: RabbitMQ/Kafka (async processing)
Service Endpoints:
@RestController
@RequestMapping("/api/v1/xbrl")
public class XBRLProcessorController {
@PostMapping("/validate")
public ResponseEntity<ValidationResult> validate(@RequestBody XBRLValidationRequest request) {
// Validate XBRL instance
}
@PostMapping("/generate")
public ResponseEntity<XBRLInstance> generate(@RequestBody XBRLGenerationRequest request) {
// Generate XBRL from data
}
@PostMapping("/transform")
public ResponseEntity<TransformResult> transform(@RequestBody XBRLTransformRequest request) {
// Transform between formats (XBRL ↔ JSON ↔ CSV)
}
@GetMapping("/taxonomy/{id}/concepts")
public ResponseEntity<List<Concept>> getConcepts(@PathVariable String id) {
// Get taxonomy concepts
}
@PostMapping("/batch/process")
public ResponseEntity<BatchJob> processBatch(@RequestBody BatchRequest request) {
// Async batch processing
}
@GetMapping("/batch/{jobId}/status")
public ResponseEntity<BatchStatus> getBatchStatus(@PathVariable String jobId) {
// Get batch job status
}
}
Deployment (Kubernetes):
# kubernetes-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: glomidco-xbrl-service
spec:
replicas: 3 # Scale as needed
selector:
matchLabels:
app: glomidco-xbrl
template:
metadata:
labels:
app: glomidco-xbrl
spec:
containers:
- name: xbrl-processor
image: glomidco/xbrl-service:1.0.0
ports:
- containerPort: 8080
resources:
requests:
memory: "2Gi"
cpu: "1000m"
limits:
memory: "8Gi"
cpu: "4000m"
env:
- name: TAXONOMY_CACHE_SIZE
value: "2GB"
- name: MAX_INSTANCE_SIZE
value: "100MB"
livenessProbe:
httpGet:
path: /actuator/health
port: 8080
initialDelaySeconds: 30
periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
name: glomidco-xbrl-service
spec:
selector:
app: glomidco-xbrl
ports:
- port: 80
targetPort: 8080
type: LoadBalancer
Pre-built Integration Flow: "ERP to XBRL"
<!-- Integration Flow: SAP_ERP_to_XBRL_Regulatory_Filing -->
<integration-flow>
<name>SAP ERP to XBRL Regulatory Filing</name>
<description>
Transform SAP ERP financial data into XBRL format for regulatory reporting.
Supports: Dutch SBR, COREP, FINREP
</description>
<!-- Configuration -->
<properties>
<property name="taxonomy" value="sbr-rj-2024"/>
<property name="entryPoint" value="full"/>
<property name="reportingPeriod" value="${date:now:yyyy-MM-dd}"/>
<property name="companyCode" value="1000"/>
<property name="xbrlService" value="https://xbrl-service.company.com/api/v1"/>
</properties>
<!-- Flow Steps -->
<start>
<timer expression="0 0 1 * * ?"/> <!-- Daily at 1 AM -->
</start>
<!-- Step 1: Extract from SAP -->
<odata-call>
<service>SAP_S4HANA</service>
<entity>FinancialStatementData</entity>
<filter>CompanyCode eq '${property.companyCode}' and Period eq '${property.reportingPeriod}'</filter>
</odata-call>
<!-- Step 2: Transform to XBRL input format -->
<groovy-script>
<script>
import com.sap.it.api.mapping.*
def mapToXBRLInput(json) {
// Map SAP fields to XBRL concepts
return [
facts: [
[concept: "Assets", value: json.TotalAssets],
[concept: "Liabilities", value: json.TotalLiabilities],
// ... more mappings
]
]
}
</script>
</groovy-script>
<!-- Step 3: Call XBRL service -->
<http-adapter>
<url>${property.xbrlService}/xbrl/generate</url>
<method>POST</method>
<authentication>OAuth2</authentication>
<body>
{
"taxonomy": "${property.taxonomy}",
"entryPoint": "${property.entryPoint}",
"data": ${body}
}
</body>
</http-adapter>
<!-- Step 4: Validate response -->
<groovy-script>
<script>
def validateXBRL(response) {
if (!response.validation.isValid) {
throw new Exception("XBRL validation failed: " + response.validation.errors)
}
return response.output.content
}
</script>
</groovy-script>
<!-- Step 5: Store XBRL instance -->
<sftp-adapter>
<server>sftp.regulator.gov</server>
<path>/submissions/${date:now:yyyy/MM/dd}/</path>
<filename>company_${property.companyCode}_${date:now:yyyyMMdd}.xbrl</filename>
</sftp-adapter>
<!-- Step 6: Send notification -->
<mail-adapter>
<to>finance@company.com</to>
<subject>XBRL Filing Submitted - ${property.reportingPeriod}</subject>
<body>XBRL filing completed successfully.</body>
</mail-adapter>
<exception-subprocess>
<mail-adapter>
<to>admin@company.com</to>
<subject>XBRL Filing FAILED</subject>
<body>${exception.message}</body>
</mail-adapter>
</exception-subprocess>
</integration-flow>
Pre-built Templates Library:
GLOMIDCO XBRL Integration Flow Templates:
├─ SAP_ERP_to_XBRL_Annual_Report
├─ SAP_ERP_to_XBRL_Tax_Filing
├─ SAP_Banking_to_COREP
├─ SAP_Banking_to_FINREP
├─ XBRL_Instance_Validation
├─ XBRL_to_JSON_Transform
├─ XBRL_to_Excel_Report
├─ Multi_Company_XBRL_Consolidation
├─ XBRL_to_Data_Warehouse
└─ XBRL_Regulatory_Submission_Workflow
For SAP Customers:
Benefits:
├─ Native XBRL Support in SAP
│ └─ No need for external XBRL vendors
├─ Seamless Integration
│ └─ Direct SAP ERP → XBRL → Regulator
├─ Cost Savings
│ └─ Eliminate middleware vendors
├─ Faster Time-to-Market
│ └─ Pre-built integration flows
├─ Regulatory Compliance
│ └─ Stay current with taxonomy updates
└─ Reduced IT Complexity
└─ Single integration platform (CPI)
For GLOMIDCO:
Opportunities:
├─ Market Access
│ └─ Access to 25,000+ SAP customers
├─ SAP Partnership
│ └─ Potential SAP certification/partnership
├─ Recurring Revenue
│ └─ Subscription model for XBRL service
├─ Content Packages
│ └─ Sell pre-built integration flows
├─ Professional Services
│ └─ Implementation consulting
└─ Support Contracts
└─ Ongoing support and maintenance
Primary Use Cases:
1. Regulatory Financial Reporting
├─ Companies: Banks, insurance, large enterprises
├─ Jurisdictions: Netherlands (SBR), EU (ESEF), US (SEC)
├─ Frequency: Quarterly, Annual
└─ Value: Automated compliance
2. Tax Reporting
├─ Companies: All SAP customers
├─ Jurisdictions: Netherlands (VPB/BTW), UK (HMRC), others
├─ Frequency: Monthly, Quarterly, Annual
└─ Value: Eliminate manual work
3. Banking Regulatory Reporting
├─ Companies: Banks
├─ Reports: COREP, FINREP, AnaCredit
├─ Frequency: Monthly, Quarterly
└─ Value: Handle 60+ complex tables
4. Multi-Country Reporting
├─ Companies: Multinationals
├─ Challenge: Different XBRL taxonomies per country
├─ Solution: Single integration platform
└─ Value: Consistency, efficiency
5. Data Integration and Analytics
├─ Scenario: XBRL data → SAP Analytics Cloud
├─ Use: Regulatory data analysis
└─ Value: Business intelligence
Current Market:
XBRL Solutions for SAP:
├─ Point Solutions
│ ├─ Workiva
│ ├─ Toppan Merrill
│ ├─ CoreFiling
│ └─ Limitations: Separate platforms, high cost
├─ Consulting Implementations
│ ├─ Big 4 custom solutions
│ └─ Limitations: Expensive, not reusable
└─ Manual Processes
├─ Excel + XBRL tools
└─ Limitations: Error-prone, not scalable
GLOMIDCO in CPI Advantages:
Competitive Advantages:
├─ Native SAP Integration
│ └─ No external platforms needed
├─ Lower Total Cost of Ownership
│ └─ Eliminate point solution licenses
├─ Faster Implementation
│ └─ Pre-built flows vs. custom development
├─ Automatic Updates
│ └─ Taxonomy updates via service
├─ Scalability
│ └─ Cloud-native, elastic scaling
└─ Comprehensive Support
└─ Single support channel (SAP + GLOMIDCO)
Option 1: Embedded JAR (One-time License)
GLOMIDCO XBRL Lite for SAP CPI
├─ License: €25,000 - €50,000 (perpetual)
├─ Annual Maintenance: 20% of license
├─ Includes:
│ ├─ JAR library
│ ├─ Basic integration flows
│ ├─ Documentation
│ └─ Email support
└─ Limitations: No Formula, no Table Linkbase
Option 2: External Service (Subscription)
GLOMIDCO XBRL Cloud Service
├─ Subscription: €5,000 - €20,000/month
├─ Pricing Tiers:
│ ├─ Basic: 1,000 transactions/month
│ ├─ Professional: 10,000 transactions/month
│ └─ Enterprise: Unlimited
├─ Includes:
│ ├─ Full XBRL processing
│ ├─ All taxonomies
│ ├─ Integration flows
│ ├─ 24/7 support
│ └─ SLA guarantees
└─ Features: Formula, Table Linkbase, everything
Option 3: Hybrid (Recommended)
GLOMIDCO XBRL Complete Package
├─ Setup Fee: €50,000
├─ Annual Subscription: €60,000 - €120,000
├─ Includes:
│ ├─ Embedded JAR (lightweight)
│ ├─ External service access (full-featured)
│ ├─ Pre-built integration flows
│ ├─ Taxonomy updates (automatic)
│ ├─ Professional services (40 hours/year)
│ └─ Priority support
└─ Best Value: Complete solution
Option 4: Content Packages (Marketplace)
SAP CPI Marketplace
├─ Individual Integration Flows: €2,500 - €5,000 each
├─ Content Packages: €10,000 - €25,000
│ ├─ "Dutch SBR Complete Package"
│ ├─ "COREP/FINREP Banking Package"
│ ├─ "Multi-Country Tax Package"
│ └─ "XBRL Analytics Package"
├─ Revenue Share: SAP 30%, GLOMIDCO 70%
└─ Benefits: Marketplace visibility, SAP distribution
Objectives:
Deliverables:
Phase 1 Deliverables:
├─ GLOMIDCO-XBRL-Lite.jar (embedded)
│ ├─ Basic XBRL parsing
│ ├─ Simple validation
│ └─ Size: <30 MB
├─ Integration Flow: "SAP to XBRL Simple"
│ ├─ Read from SAP OData
│ ├─ Transform to XBRL
│ └─ Validate and output
├─ Documentation
│ ├─ Technical architecture
│ ├─ Integration guide
│ └─ API documentation
└─ Demo Environment
├─ SAP CPI tenant
├─ Test data
└─ Working end-to-end flow
Timeline:
Month 1: Architecture & Design
├─ Week 1-2: Requirements gathering
├─ Week 3-4: Architecture design
Month 2: Development
├─ Week 5-6: Build embedded JAR
├─ Week 7-8: Create integration flow
Month 3: Testing & Demo
├─ Week 9-10: Integration testing
├─ Week 11-12: Demo and documentation
Objectives:
Deliverables:
Phase 2 Deliverables:
├─ GLOMIDCO XBRL Microservice
│ ├─ REST API
│ ├─ Full XBRL processing
│ ├─ Formula support
│ ├─ 3 taxonomies: SBR-RJ, US GAAP, IFRS
│ └─ Deployed on Kubernetes
├─ Enhanced Embedded JAR
│ └─ With hybrid routing logic
├─ Integration Flow Templates (5)
│ ├─ SAP ERP to SBR-RJ
│ ├─ SAP ERP to US GAAP XBRL
│ ├─ XBRL Validation Flow
│ ├─ XBRL to JSON Transform
│ └─ XBRL Analytics Extract
├─ Monitoring & Operations
│ ├─ Prometheus metrics
│ ├─ Grafana dashboards
│ └─ Alert configuration
└─ Documentation Package
├─ Installation guide
├─ Configuration guide
├─ Operations manual
└─ Troubleshooting guide
Objectives:
Deliverables:
Phase 3 Deliverables:
├─ Complete Taxonomy Support
│ ├─ Dutch SBR (all families)
│ ├─ COREP/FINREP (Table Linkbase)
│ ├─ US SEC EDGAR
│ ├─ UK HMRC iXBRL
│ ├─ ESEF (EU listed companies)
│ └─ 20+ total taxonomies
├─ Advanced Features
│ ├─ Batch processing
│ ├─ Async job handling
│ ├─ Multi-tenancy
│ └─ Advanced caching
├─ Content Package Library
│ ├─ 20+ integration flows
│ ├─ Industry-specific packages
│ └─ Regional packages
├─ SAP Certification
│ ├─ SAP Integration certification
│ ├─ SAP Marketplace listing
│ └─ SAP co-marketing
└─ Production Operations
├─ 24/7 support
├─ SLA guarantees
├─ Security audits
└─ Compliance certifications
Authentication & Authorization:
Security Layers:
├─ CPI to XBRL Service
│ ├─ OAuth2 / JWT
│ ├─ Mutual TLS (mTLS)
│ ├─ API key per tenant
│ └─ Rate limiting
├─ Data Encryption
│ ├─ In-transit: TLS 1.3
│ ├─ At-rest: AES-256
│ └─ Key management: Azure Key Vault / AWS KMS
├─ Network Security
│ ├─ Private endpoints (VPC)
│ ├─ Firewall rules
│ ├─ DDoS protection
│ └─ IP whitelisting
└─ Compliance
├─ GDPR compliance
├─ SOC 2 Type II
├─ ISO 27001
└─ Regular penetration testing
Performance Targets:
Latency Targets:
├─ Simple processing (embedded JAR): <500ms
├─ Complex processing (external service): <5 seconds
├─ Batch processing: 100 files/minute
└─ Concurrent requests: 100+ simultaneous
Throughput Targets:
├─ Small instances (<1 MB): 1,000/hour
├─ Medium instances (1-10 MB): 500/hour
├─ Large instances (10-40 MB): 100/hour
└─ Batch jobs: 10,000 files/day
Resource Usage:
├─ Memory: 4-8 GB per service instance
├─ CPU: 2-4 cores per instance
├─ Storage: 100 GB (taxonomies + cache)
└─ Network: 1 Gbps
Optimization Strategies:
Optimizations:
├─ Taxonomy Caching
│ ├─ In-memory cache (Redis)
│ ├─ Pre-loaded common taxonomies
│ └─ Cache hit rate: >90%
├─ Connection Pooling
│ ├─ HTTP client connection pool
│ └─ Database connection pool
├─ Horizontal Scaling
│ ├─ Kubernetes HPA (Horizontal Pod Autoscaling)
│ ├─ Scale based on CPU/memory
│ └─ Min: 3 replicas, Max: 20 replicas
└─ Async Processing
├─ Job queue (RabbitMQ/Kafka)
├─ Background workers
└─ Status polling API
Monitoring Stack:
Observability:
├─ Metrics (Prometheus)
│ ├─ Request rate
│ ├─ Error rate
│ ├─ Response times (p50, p95, p99)
│ ├─ Memory usage
│ ├─ CPU usage
│ └─ Cache hit rates
├─ Logging (ELK Stack)
│ ├─ Application logs
│ ├─ Audit logs
│ ├─ Error logs
│ └─ Request/response logs
├─ Tracing (Jaeger)
│ ├─ Distributed tracing
│ ├─ Request flow visualization
│ └─ Performance bottleneck identification
└─ Dashboards (Grafana)
├─ System health dashboard
├─ Business metrics dashboard
├─ SLA compliance dashboard
└─ Alert management
Alerting:
Alert Rules:
├─ Critical
│ ├─ Service down (5xx errors >5%)
│ ├─ Response time >10s (p95)
│ └─ Memory usage >90%
├─ Warning
│ ├─ Error rate >1%
│ ├─ Response time >5s (p95)
│ └─ Memory usage >75%
└─ Info
├─ Deployment completed
├─ Scaling event
└─ Cache miss rate increase
Primary Targets:
Tier 1: SAP Customers with Regulatory Reporting
├─ Banks (COREP/FINREP)
├─ Insurance companies (Solvency II)
├─ Large enterprises (ESEF, SEC)
└─ Size: 500+ companies globally
Tier 2: SAP Customers in Netherlands
├─ All Dutch companies using SAP
├─ Mandatory SBR compliance
└─ Size: 1,000+ companies in Netherlands
Tier 3: SAP System Integrators
├─ SAP consulting partners
├─ Implementation partners
└─ Size: 50+ SIs globally
Market Size:
Total Addressable Market (TAM):
├─ SAP customers worldwide: 440,000+
├─ SAP customers with XBRL needs: ~50,000
├─ Potential revenue: €250M - €500M annually
Serviceable Addressable Market (SAM):
├─ SAP CPI customers: ~10,000
├─ With regulatory reporting: ~5,000
└─ Potential revenue: €50M - €100M annually
Serviceable Obtainable Market (SOM):
├─ Target (Year 3): 100-200 customers
└─ Revenue target: €5M - €10M annually
Channel Strategy:
1. Direct Sales (GLOMIDCO)
├─ Enterprise sales team
├─ Target: Fortune 2000 SAP customers
└─ ACV: €50,000 - €500,000
2. SAP Marketplace
├─ List integration flows
├─ Content packages
└─ Self-service purchases
3. SAP Partner Channel
├─ SAP Partner certification
├─ Co-selling with SAP
└─ Joint go-to-market
4. System Integrators
├─ Partner with SAP SIs
├─ Train SI teams
└─ Revenue share model
5. Resellers
├─ Authorize regional resellers
├─ Provide training and support
└─ Channel margin: 20-30%
Marketing Tactics:
1. Content Marketing
├─ Blog posts on SAP + XBRL
├─ Technical whitepapers
├─ Webinars
└─ Case studies
2. Events
├─ SAP conferences (SAPPHIRE)
├─ XBRL conferences
├─ Regional events
└─ Partner workshops
3. Digital Marketing
├─ LinkedIn targeting (SAP decision-makers)
├─ Google Ads (SAP XBRL keywords)
├─ SEO optimization
└─ Email campaigns
4. SAP Ecosystem
├─ SAP Marketplace listing
├─ SAP App Center
├─ SAP Community contributions
└─ SAP Blogs and articles
5. Partnership Marketing
├─ Co-marketing with SAP
├─ Joint customer success stories
├─ SI partner enablement
└─ Analyst relations (Gartner, Forrester)
Risk Matrix:
| Risk | Probability | Impact | Mitigation |
|---|---|---|---|
| CPI resource constraints | Medium | High | Hybrid architecture (embedded + external) |
| SAP platform changes | Low | High | Stay current with SAP roadmap, partnerships |
| Performance issues | Medium | Medium | Thorough performance testing, optimization |
| Taxonomy updates | High | Medium | Automated update process, subscription model |
| Security vulnerabilities | Low | Very High | Regular security audits, penetration testing |
| Integration complexity | Medium | Medium | Pre-built templates, documentation, training |
| Risk | Probability | Impact | Mitigation |
|---|---|---|---|
| Low customer adoption | Medium | High | Strong value proposition, easy onboarding |
| Competition from SAP | Low | Very High | Partner with SAP, become preferred solution |
| Point solution vendors | Medium | Medium | Superior integration, lower TCO |
| Regulatory changes | High | Medium | Stay current with taxonomies, flexible architecture |
| Economic downturn | Medium | Medium | Subscription model, flexible pricing |
Technical Success Metrics:
├─ Performance
│ ├─ Latency (embedded): <500ms (95th percentile)
│ ├─ Latency (external): <5s (95th percentile)
│ ├─ Throughput: >1,000 transactions/hour
│ └─ Uptime: 99.9% SLA
├─ Quality
│ ├─ Error rate: <0.1%
│ ├─ Validation accuracy: 100% (vs. manual)
│ ├─ Test coverage: >90%
│ └─ Security scan: Zero critical vulnerabilities
└─ Scalability
├─ Concurrent users: 100+
├─ Horizontal scaling: Auto-scale working
└─ Resource efficiency: <4 GB per instance
Business Success Metrics (Year 1):
├─ Customer Acquisition
│ ├─ POC customers: 10+
│ ├─ Paying customers: 5+
│ └─ Pipeline: 50+ qualified leads
├─ Revenue
│ ├─ ARR (Annual Recurring Revenue): €250,000+
│ ├─ Professional services: €100,000+
│ └─ Total revenue: €350,000+
├─ SAP Partnership
│ ├─ SAP certification: Achieved
│ ├─ Marketplace listing: Live
│ └─ Co-selling agreements: 2+
└─ Product Adoption
├─ Integration flows deployed: 100+
├─ Transactions processed: 1M+
└─ Customer satisfaction: NPS >50
✅ Technical Feasibility: HIGH
✅ Business Opportunity: STRONG
✅ Competitive Advantage: SIGNIFICANT
1. Start with Hybrid Approach
Why Hybrid:
├─ Best balance of performance and functionality
├─ Addresses both simple and complex use cases
├─ Flexible deployment (on-premise and cloud)
└─ Gradual migration path for customers
2. Focus on High-Value Use Cases First
Priority Order:
1. Dutch SBR (proven market, mandatory)
2. Banking COREP/FINREP (complex, high value)
3. US SEC EDGAR (large market)
4. EU ESEF (growing mandate)
3. Build SAP Partnership Early
Partnership Strategy:
├─ Engage SAP partner team
├─ Pursue SAP certification
├─ Co-develop reference architecture
├─ Joint go-to-market planning
└─ Target: SAP Preferred Partner status
4. Create Content Packages
Marketplace Strategy:
├─ Pre-built integration flows
├─ Industry-specific packages
├─ Regional taxonomy packages
├─ Quick-start templates
└─ Generate marketplace revenue + visibility
Immediate Actions (Month 1):
1. Form project team (GLOMIDCO + SAP experts)
2. Engage with SAP partner team
3. Set up CPI developer environment
4. Create technical architecture document
5. Build initial JAR prototype
Short-term (Months 2-3):
1. Develop POC with one customer
2. Build embedded JAR (lightweight)
3. Create one end-to-end integration flow
4. Present demo to SAP and customers
5. Refine architecture based on feedback
Medium-term (Months 4-12):
1. Build external microservice
2. Implement hybrid routing
3. Support 3-5 major taxonomies
4. Develop 10+ integration flows
5. Achieve SAP certification
6. Launch SAP Marketplace listing
7. Acquire first 5 paying customers
┌─────────────────────────────────────────────────────────────────────────────┐
│ SAP ENTERPRISE │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ SAP ERP │ │ SAP S/4HANA │ │ SAP Banking │ │ SAP BW/4 │ │
│ │ (ECC) │ │ │ │ │ │ │ │
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │ │ │
│ └─────────────────┴─────────────────┴─────────────────┘ │
│ │ │
│ │ OData / RFC / IDOC │
│ │ │
└────────────────────────────────────┼────────────────────────────────────────┘
│
│
┌────────────────────────────────────▼────────────────────────────────────────┐
│ SAP CLOUD PLATFORM INTEGRATION (CPI) │
│ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ Integration Flow: ERP to XBRL │ │
│ │ │ │
│ │ [Receive] → [Transform] → [Route] → [XBRL Process] → [Send] │ │
│ │ │ │ │
│ │ ┌────┴────┐ │ │
│ │ SIMPLE│ │COMPLEX │ │
│ │ │ │ │ │
│ │ ┌────▼───▼────┐ │ │
│ │ │ Decision │ │ │
│ │ │ Router │ │ │
│ │ └────┬───┬────┘ │ │
│ │ │ │ │ │
│ │ ┌──────────┘ └──────────┐ │ │
│ │ │ │ │ │
│ │ ┌───────▼────────┐ ┌────────▼────────┐ │ │
│ │ │ Groovy Script │ │ HTTP Adapter │ │ │
│ │ │ (Embedded JAR) │ │ External Call │ │ │
│ │ └───────┬────────┘ └────────┬────────┘ │ │
│ │ │ │ │ │
│ │ │ │ │ │
│ │ ┌──────▼──────┐ │ │ │
│ │ │ GLOMIDCO │ │ │ │
│ │ │ XBRL Lite │ │ │ │
│ │ │ JAR Library │ │ │ │
│ │ └──────┬──────┘ │ │ │
│ │ │ │ │ │
│ │ └────────────┬───────────┘ │ │
│ │ │ │ │
│ │ ┌──────▼──────┐ │ │
│ │ │XBRL Instance│ │ │
│ │ └──────┬──────┘ │ │
│ │ │ │ │
│ │ [Store] ← [Validate] ← [Transform] ← [Route] │ │
│ └───────────────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────┬────────────────────────────────────┘
│
│ HTTPS / REST API
│
┌────────────────────────────────────────▼────────────────────────────────────┐
│ GLOMIDCO XBRL MICROSERVICE │
│ (External Service) │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ REST API Layer │ │
│ │ /api/v1/xbrl/validate /generate /transform /batch │ │
│ └────────────────────────────────┬────────────────────────────────────┘ │
│ │ │
│ ┌────────────────────────────────▼────────────────────────────────────┐ │
│ │ GLOMIDCO Full Processor │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ XBRL Core │ │ Formula │ │Table Linkbase│ │ │
│ │ │ Engine │ │ Processor │ │ Processor │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ Dimensions │ │ Saxon │ │ Validation │ │ │
│ │ │ Handler │ │ XPath 2.0 │ │ Engine │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ Supporting Services │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ Redis │ │ RabbitMQ │ │ S3/Blob │ │ │
│ │ │ Cache │ │ Queue │ │ Storage │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────────────┘
│
│
▼
┌────────────────────────────────────────────────────────────────────────────┐
│ DESTINATIONS │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Regulator │ │ SFTP │ │ Archive │ │ Analytics │ │
│ │ Portal │ │ Server │ │ S3/Blob │ │ SAC/BW │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ │
└────────────────────────────────────────────────────────────────────────────┘
Document Status: Strategic Analysis Complete
Recommendation: PROCEED with hybrid approach
Priority: HIGH - Strong business case and technical feasibility
Next Action: Form project team and engage SAP partnership
End of Document