DraftInternal

SW-SAAS-ONB-COMP-001

Onboarding Addendum - Communications

Version

1.0

Owner

Technical Architect

Effective Date

2025-01-15

Review Date

2026-01-15

Onboarding Addendum: Communications

Document ID: SW-SAAS-ONB-COMP-001
Version: 1.0
Effective Date: 2025-01-15
Parent Document: SW-SAAS-ONB-001 (Main Onboarding Guide)

This addendum provides component-specific onboarding steps for customers subscribing to Swedwise Communications service (OpenText Exstream). It supplements the main onboarding guide (SW-SAAS-ONB-001) with detailed procedures for:

OpenText Communications (Exstream) tenant setup
Template development and migration
Document generation integration
Batch processing configuration

1.2. Relationship to Main Onboarding Guide

This addendum should be used in conjunction with the main onboarding guide:

Main Guide Phase	Addendum Section	Timeline Overlap
Phase 2: Technical Setup	Section 3: Tenant Provisioning	Week 2-4
Phase 3: Configuration	Section 4-6: Template & Integration	Week 6-14
Phase 4: Training & Go-Live	Section 7-9: Training & Testing	Week 14-18

1.3. Timeline Overview

Total Component Onboarding: 6-10 weeks (in parallel with main onboarding)

Phase	Duration	Key Deliverables
Tenant Provisioning	Week 1-2	Production and dev tenants ready
Template Development	Week 3-8	Templates designed, developed, tested
Integration Implementation	Week 4-10	APIs integrated, batch processes configured
Testing Phase	Week 8-10	UAT complete, performance verified
Training	Week 9-10	Users trained and certified

1.4. Roles Specific to This Component

Role	Responsibilities	Required Skills
Template Designer	Design and develop document templates	OpenText Designer experience, design skills
Integration Developer	Build API integrations	API development, JSON/XML, authentication
Content Owner	Define document requirements, approve templates	Business knowledge, content expertise

2. Prerequisites

2.1. Technical Requirements

Infrastructure:

Internet connectivity to Swedwise data center (see main guide)
Firewall rules configured for API access (ports 443, 8443)
Outbound HTTPS allowed for API calls

Software:

OpenText Designer installed (version 23.x or later)
Compatible web browser (Chrome 110+, Edge 110+, Firefox 110+)
PDF viewer (for testing output)
API development tools (Postman, cURL, or similar)

System Requirements for Designer Workstation:

Windows 10/11 or Windows Server 2016+
8 GB RAM minimum (16 GB recommended)
10 GB free disk space
.NET Framework 4.8+

2.2. Data Preparation

Document Inventory:

Complete the following inventory for each document type:

Document Type	Current Volume	Frequency	Channels	Priority
Customer Invoice	[monthly volume]	Monthly	Email, Print	High
Payment Reminder	[volume]	Weekly	Email, SMS	High
Account Statement	[volume]	Monthly	Email, Print	Medium
[Add others]

Data Source Mapping:

For each document type, identify:

Source system (CRM, ERP, custom database)
Data format (XML, JSON, CSV, database query)
Data elements required
Sample data files (minimum 5 samples)
Data refresh frequency
Data volume estimates

Content Assets:

Gather the following content assets:

Company logo (high resolution, vector format preferred)
Brand guidelines (colors, fonts, styling)
Existing document templates (Word, PDF, etc.)
Legal text and disclaimers
Letterhead and footer content
Signature images (if applicable)

Template: Download Document Inventory Worksheet from customer portal

2.3. Template Design Resources

Design Team:

Template designer identified and assigned
Content owner identified per document type
Approval authority designated
Review schedule established

Design Standards:

Brand guidelines reviewed
Accessibility requirements defined (WCAG, PDF/UA)
Multi-language requirements identified
Output formats specified (PDF, HTML, print)

3. Tenant Provisioning

3.1. Production Tenant Setup

Swedwise Actions:

Tenant Creation (Week 1)
- Production tenant created in Kubernetes cluster
- Tenant ID assigned: [CUSTOMER-PROD]
- Database schema initialized
- Storage allocation configured
- Default settings applied
Initial Configuration
- Timezone configured per customer location
- Locale settings applied (language, date format)
- Document retention policy set
- Audit logging enabled
- Monitoring configured

Access URLs Provided

Admin Portal:    https://[customer]-prod.swedwise-saas.com/admin
Designer Portal: https://[customer]-prod.swedwise-saas.com/designer
API Endpoint:    https://api.swedwise-saas.com/v1/[customer-prod]

Customer Verification:

Access to admin portal verified
Initial dashboard accessible
Settings review completed
No errors in initial login

3.2. Development Tenant Setup

Purpose: Safe environment for template development and integration testing

Swedwise Actions:

Development Tenant Creation (Week 1)
- Development tenant created
- Tenant ID assigned: [CUSTOMER-DEV]
- Mirrored configuration from production
- Test data loaded (sample data set)
Designer Access
- Designer installation packages provided
- License keys issued for development
- Connection profiles created
- Designer access credentials provided

Access URLs:

Admin Portal:    https://[customer]-dev.swedwise-saas.com/admin
Designer Portal: https://[customer]-dev.swedwise-saas.com/designer
API Endpoint:    https://api.swedwise-saas.com/v1/[customer-dev]

Best Practices:

Always develop and test in DEV environment first
Use production-like data (anonymized if necessary)
Test all integrations in DEV before production deployment
Maintain template version control

3.3. Tenant Isolation Verification

Security Check:

Data isolation verified between tenants
Cross-tenant access blocked
Tenant-specific encryption keys confirmed
Audit logs show only tenant-specific activity

Performance Baseline:

Initial performance metrics captured
Response time baselines established
Resource allocation verified
Scaling thresholds configured

4. Template Development

4.1. Template Designer Access and Setup

Installation (Week 2)

Download Designer
- Download link provided by Swedwise
- Installer downloaded to designer workstation
- Virus scan completed
Installation
- Run installer with administrator privileges
- Accept license agreement
- Select installation directory
- Complete installation wizard
Initial Configuration
- Launch OpenText Designer
- Configure connection to development tenant
```
Server URL: https://[customer]-dev.swedwise-saas.com
Username: [designer-username]
Password: [secure-password]
Tenant ID: [CUSTOMER-DEV]
```
- Test connection successful
- Designer workspace configured

License Activation:

License key entered
License activated and verified
Expiration date confirmed (annual renewal)

4.2. Sample Templates

Swedwise Provides:

Standard sample templates to accelerate development:

Invoice Template
- Simple invoice with line items
- Logo placement
- Payment terms section
- Total calculations
Letter Template
- Standard business letter format
- Letterhead and footer
- Address block
- Signature block
Statement Template
- Multi-page statement with transactions
- Summary page
- Detail pages with pagination
- Charts and graphs

Sample Data:

XML sample data files provided
JSON sample data files provided
Data mapping documentation included

Usage:

Use samples as starting point for customization
Learn best practices from sample structure
Reference for common design patterns
Not production-ready; customization required

4.3. Template Development Process

Recommended Workflow:

Phase 1: Design (Week 3-4)

Requirements Gathering
- Meet with content owner
- Review existing documents
- Document requirements document created
- Mockup/wireframe approved
Template Design
- Create new template in Designer
- Import brand assets (logo, fonts, colors)
- Build page layouts (master pages)
- Add static content (headers, footers, legal text)
- Create reusable components
Data Mapping
- Import sample data file
- Map data fields to template elements
- Configure conditional content rules
- Set up calculations and formulas
- Define repeating sections (tables, lists)

Deliverable: Draft template with sample data

Phase 2: Development (Week 5-6)

Advanced Features
- Multi-language support (if required)
- Dynamic content rules
- Charts and graphs
- Barcodes and QR codes
- Digital signatures (if required)
Output Formatting
- PDF output optimized
- Print output tested (if applicable)
- HTML email version (if applicable)
- Accessibility features (PDF/UA compliance)
Testing with Real Data
- Real data samples obtained (anonymized)
- Template tested with edge cases
- Error handling verified
- Performance tested (large documents)

Deliverable: Fully functional template

Phase 3: Review and Approval (Week 7)

Internal Review
- Template designer self-review checklist complete
- Peer review conducted
- Quality assurance testing
Content Owner Review
- Sample outputs generated
- Content accuracy verified
- Brand compliance confirmed
- Legal review (if required)
Approval
- Formal sign-off from content owner
- Template version tagged
- Template published to development tenant
- Template documentation completed

Template Documentation Should Include:

Template name and version
Data schema/mapping
Supported output formats
Known limitations
Maintenance notes

Phase 4: Deployment (Week 8)

Staging Deployment
- Template exported from Designer
- Template imported to production tenant
- Configuration verified
- Test generation run in production
Production Verification
- Sample production data tested
- Output quality verified
- Performance acceptable
- Template activated for production use

Template Versioning:

Use semantic versioning: MAJOR.MINOR.PATCH
Document changes in changelog
Maintain backward compatibility when possible
Test thoroughly before production deployment

4.4. Best Practices Guide

Design Best Practices:

Performance Optimization
- Minimize complex calculations
- Optimize image sizes and formats
- Use template fragments for reusable content
- Limit font variations
Maintainability
- Use clear naming conventions
- Comment complex logic
- Modularize template components
- Document data dependencies
Accessibility
- Use semantic PDF tags
- Provide alt text for images
- Ensure sufficient color contrast
- Support screen readers
Multi-language Support
- Externalize all text strings
- Use locale-aware date/number formatting
- Test with longest translated strings
- Consider right-to-left languages if needed

Common Pitfalls to Avoid:

Hard-coding content that should be data-driven
Over-complex conditional logic
Missing error handling for null data
Insufficient testing with edge cases

5. Integration Implementation

5.1. Document Generation API Setup

API Credentials (Week 4)

Generate API Keys
- Login to admin portal
- Navigate to API Management section
- Generate new API key pair (public/private)
- Download credentials securely
- Store in password manager or vault

API Key Format:

API Key ID:     sw_prod_[random-string]
API Secret:     [64-character-secret]
API Endpoint:   https://api.swedwise-saas.com/v1/[customer-prod]

API Configuration
- Set rate limits (requests per minute)
- Configure IP allowlist (if required)
- Enable webhook notifications (optional)
- Set request timeout values

Authentication Example:

curl -X POST https://api.swedwise-saas.com/v1/[customer-prod]/documents/generate \
  -H "Authorization: Bearer ${API_SECRET}" \
  -H "Content-Type: application/json" \
  -d '{
    "template_id": "invoice_v1",
    "output_format": "pdf",
    "data": {
      "customer_name": "Acme Corp",
      "invoice_number": "INV-2024-001",
      "items": [...]
    }
  }'

5.2. Document Generation Integration Patterns

Pattern 1: Synchronous API (Real-time Generation)

Use Case: Generate document and return immediately

Process Flow:

Your system calls API with template ID and data
Swedwise generates document
API returns document (base64 encoded or URL)
Your system saves/delivers document

Sample Request:

POST /v1/[customer-prod]/documents/generate
{
  "template_id": "invoice_v1",
  "output_format": "pdf",
  "data": {
    "invoice_number": "INV-2024-001",
    "customer": {
      "name": "Acme Corp",
      "address": "123 Main St"
    },
    "items": [
      {
        "description": "Service A",
        "quantity": 10,
        "price": 100.00
      }
    ]
  },
  "options": {
    "return_type": "url",
    "expire_hours": 24
  }
}

Sample Response:

{
  "document_id": "doc_abc123",
  "status": "completed",
  "output_url": "https://api.swedwise-saas.com/v1/documents/doc_abc123/download",
  "expires_at": "2024-01-16T10:00:00Z",
  "page_count": 3,
  "file_size_bytes": 45678
}

Pattern 2: Asynchronous API (Batch Generation)

Use Case: Generate large volumes, get notified when complete

Process Flow:

Submit batch generation job
Receive job ID
Poll for status OR receive webhook notification
Download generated documents

Sample Request:

POST /v1/[customer-prod]/documents/batch
{
  "template_id": "statement_v2",
  "output_format": "pdf",
  "batch_data": [
    { "customer_id": "CUST001", "period": "2024-01" },
    { "customer_id": "CUST002", "period": "2024-01" },
    ...
  ],
  "webhook_url": "https://your-system.com/webhooks/batch-complete"
}

Sample Response:

{
  "batch_id": "batch_xyz789",
  "status": "processing",
  "total_documents": 1500,
  "completed": 0,
  "estimated_completion": "2024-01-15T14:30:00Z"
}

Pattern 3: Data File Upload

Use Case: Upload data file (CSV, XML, JSON), generate documents for all records

Process:

Upload data file via API or SFTP
Submit generation job referencing uploaded file
Documents generated for each record
Download zip file of all documents

Implementation Steps:

Development Environment Integration (Week 4-6)
- API client library installed (or use REST)
- Authentication implemented and tested
- Sample API calls successful
- Error handling implemented
- Logging configured
Template ID Mapping
- Map business processes to template IDs
- Document template versions per environment
- Configuration management for template references
Data Transformation
- Map source data to template data schema
- Implement data validation
- Handle null/missing data gracefully
- Test with edge cases
Testing (Week 7)
- Unit tests for API client
- Integration tests with development tenant
- Load testing (if high volume expected)
- Error scenario testing
Production Deployment (Week 8)
- Update configuration for production API endpoint
- Update API credentials to production keys
- Deploy to production
- Monitor first production calls

5.3. Batch Processing Configuration

For High-Volume Scenarios:

Batch Job Scheduling
- Define batch schedules (daily, weekly, monthly)
- Configure batch submission via API or file upload
- Set retry policies for failed documents
- Configure batch completion notifications
File-Based Integration (Alternative to API)
- SFTP credentials provided by Swedwise
- Upload folder structure defined
- File naming convention agreed
- Processing schedule confirmed
- Success/failure notification configured

SFTP File Processing:

Upload Structure:
/inbound/
  /templates/
    invoice_v1.xml    (data file)
    statement_v2.json (data file)
  /processed/         (moved after processing)
  /failed/            (moved if errors)

Output Structure:
/outbound/
  /documents/
    /2024-01-15/
      invoice_001.pdf
      invoice_002.pdf
      ...

Monitoring
- Batch processing dashboard access configured
- Email notifications for batch failures
- Daily summary reports enabled

6. Testing Phase

6.1. Test Data Requirements

Sample Data Sets:

Prepare the following test data sets:

Happy Path Data (Normal scenarios)
- 10-20 typical records
- All required fields populated
- Valid data formats
Edge Case Data
- Long field values (test truncation/wrapping)
- Special characters (ÅÄÖ, €, &, <, >)
- Empty optional fields
- Minimum and maximum values
Error Scenario Data
- Missing required fields
- Invalid data types
- Out-of-range values
- Malformed XML/JSON

Test Data Anonymization:

Use production-like data structure
Anonymize personal information (GDPR compliance)
Maintain data relationships (e.g., invoice headers to line items)

6.2. User Acceptance Testing (UAT) Procedures

UAT Phase: Week 8-9

Test Planning

Define UAT Scope
- List of templates to test
- List of integration scenarios
- Acceptance criteria defined
UAT Team
- UAT lead assigned
- Business users identified (2-5 people)
- Test environment access granted
- Training on test procedures provided

Test Execution

Template Testing:

Test Case	Template	Data Set	Expected Result	Status
TC-001	Invoice v1	Happy path	PDF generated, all data correct	[ ]
TC-002	Invoice v1	Long address	Address wraps correctly	[ ]
TC-003	Invoice v1	Many line items	Pagination correct	[ ]

Integration Testing:

Test Case	Scenario	Expected Result	Status
INT-001	API: Single document generation	200 response, PDF returned	[ ]
INT-002	API: Invalid template ID	404 error, clear message	[ ]
INT-003	API: Missing required data	400 error, validation details	[ ]
INT-004	Batch: 100 documents	All generated, job completed	[ ]

Defect Management

Defect Logging:

Use Swedwise support portal to log defects
Severity levels: Critical, High, Medium, Low
Include: Test case ID, steps to reproduce, expected vs actual result, screenshots

Defect Resolution:

Critical: Fixed within 24 hours
High: Fixed within 3 business days
Medium: Fixed before go-live
Low: May be deferred to post-go-live

UAT Sign-Off

All critical and high defects resolved
95%+ of test cases passed
Business users accept functionality
UAT sign-off document signed

Template: Download UAT Sign-Off Template from customer portal

6.3. Performance Testing

For High-Volume Customers:

Load Test Scenarios
- Peak hour simulation (expected concurrent API calls)
- Batch processing test (largest expected batch)
- Sustained load test (average daily volume over 1 hour)
Performance Metrics

Metric	Target	Actual	Status
API response time (single doc)	< 5 seconds
API response time (95th percentile)	< 10 seconds
Batch throughput	>= 500 docs/hour
Error rate	< 0.1%

Performance Tuning
- Identify bottlenecks
- Optimize templates if needed
- Adjust API rate limits if needed
- Scale infrastructure if needed

Note: Swedwise conducts performance testing for you. Results shared in performance report.

7. Training (Component-Specific)

7.1. Template Designer Training

Duration: 4 hours (hands-on)

Audience: Template designers, technical staff who will maintain templates

Prerequisites:

OpenText Designer installed on workstation
Access to development tenant
Sample data files available

Curriculum:

Module 1: Designer Basics (1 hour)

Designer interface overview
Creating a new template
Importing data sources
Basic layout and formatting
Testing and preview

Module 2: Advanced Features (1.5 hours)

Dynamic content and conditional rules
Calculations and formulas
Repeating sections and tables
Multi-page documents
Charts and graphs

Module 3: Best Practices (1 hour)

Performance optimization
Template maintainability
Accessibility features
Version control
Common pitfalls

Module 4: Hands-On Exercise (0.5 hours)

Build a simple invoice template
Map data fields
Test with sample data
Deploy to development tenant

Deliverables:

Training materials (slides, exercises)
Sample templates
Designer quick reference guide
Certificate of completion

7.2. Administrator Training

Duration: 3 hours

Audience: System administrators, tenant administrators

Curriculum:

Module 1: Admin Portal (1 hour)

Dashboard and navigation
User management
Template management
Configuration settings
Audit logs and reporting

Module 2: Monitoring and Troubleshooting (1 hour)

Document generation monitoring
Error investigation
Performance monitoring
Support ticket submission

Module 3: Maintenance Tasks (1 hour)

Template deployment
User access management
Integration health checks
Backup and recovery procedures
Quarterly review preparation

Deliverables:

Administrator guide
Troubleshooting checklist
Maintenance calendar template
Certificate of completion

7.3. API Developer Training

Duration: 3 hours (technical)

Audience: Integration developers, API consumers

Prerequisites:

API development experience
Postman or similar tool installed
Development environment access

Curriculum:

Module 1: API Overview (0.5 hours)

API architecture
Authentication and authorization
Rate limits and quotas
Error handling
Best practices

Module 2: Document Generation API (1.5 hours)

Synchronous generation
Asynchronous batch generation
Template selection
Data format and mapping
Output options (PDF, HTML, etc.)
Hands-on: Generate a document via API

Module 3: Troubleshooting (1 hour)

Reading error responses
Using API logs
Support escalation
Performance optimization

Deliverables:

API documentation (Swagger/OpenAPI)
Postman collection
Code samples (Python, C#, JavaScript)
API integration checklist

8. Migration (If Applicable)

8.1. Template Migration from Existing System

If migrating from another document generation system:

Assessment Phase:

Inventory Existing Templates
- List all existing templates
- Identify template complexity (simple, medium, complex)
- Estimate conversion effort per template
- Prioritize templates for migration
Gap Analysis
- Identify features used in old system
- Map to OpenText Communications capabilities
- Identify any unsupported features
- Plan workarounds or alternatives

Migration Approaches:

Option 1: Manual Recreation (Recommended)

Recreate templates from scratch in Designer
Opportunity to improve design and performance
Ensures best practices followed
Timeline: 1-2 weeks per complex template

Option 2: Automated Conversion (If Available)

Use conversion tools (limited availability)
Requires post-conversion cleanup
May not preserve all features
Timeline: Faster initial conversion, testing still required

Migration Process:

Pilot Migration (Week 3-4)
- Select 1-2 templates for pilot
- Recreate in Designer
- Test with production data
- Document lessons learned
Bulk Migration (Week 5-8)
- Migrate remaining templates by priority
- Review and testing for each
- Parallel run with old system (if possible)
- Cutover planning
Validation
- Side-by-side comparison of outputs
- Business user review
- Approval for production use

8.2. Configuration Migration

No customer data migration required - Swedwise Communications generates documents on-demand

Configuration Migration:

User accounts and roles (may need recreation)
Integration settings (API keys are new)
Template configurations

Document Archive Migration (Optional):

If you need historical documents migrated to new platform
Typically not required (keep old system archive for reference)
Contact Swedwise for archive migration options

9. Go-Live Checklist (Component-Specific)

9.1. Pre-Go-Live Checklist

Templates:

All production templates developed and approved
Templates deployed to production tenant
Templates tested with production data
Template documentation complete
Template version control process in place

Integrations:

All integrations tested in production environment
API credentials rotated to production keys
Integration monitoring configured
Error handling and logging verified
Rollback plan documented

Infrastructure:

Production tenant performance verified
Backup and recovery tested
Monitoring and alerting configured
Capacity planning reviewed
Security scanning completed (penetration test)

Training:

All template designers trained and certified
All administrators trained
All integration developers trained
Training materials accessible

Documentation:

Template documentation complete
Integration documentation complete
Runbooks for common tasks
Troubleshooting guides
Support escalation procedures

Testing:

UAT completed and signed off
Performance testing passed
Security testing passed
All critical defects resolved

Organizational Readiness:

Go-live communication sent to stakeholders
Support team briefed and ready
Business continuity plan in place
Rollback procedure documented and tested
Success metrics defined

9.2. Go-Live Day Activities

T-24 hours:

Final production verification by Swedwise
Customer go/no-go confirmation
Communication to all users

T-4 hours:

Pre-production health checks
Integration smoke tests
Support team on standby

T-0 (Cutover):

Switch production traffic to new platform
First production documents generated
Immediate monitoring

T+1 hour:

Smoke test results reviewed
Error logs checked
Performance metrics reviewed
Customer confirmation of success

T+4 hours:

Broader usage monitoring
Support ticket review
Any issues addressed

T+24 hours:

Day 1 review meeting
Metrics review
Issue log review
Hypercare plan confirmed

10. Appendices

Appendix A: Template Development Checklist

Design Phase:

Development Phase:

Testing Phase:

Review Phase:

Deployment Phase:

Appendix B: API Integration Checklist

Setup:

API credentials generated
Credentials stored securely
API endpoint configured
Authentication implemented

Development:

Testing:

Deployment:

Appendix C: Common Issues and Solutions

Issue	Possible Cause	Solution
Document generation fails	Invalid data format	Validate data against schema before API call
Template not found error	Wrong template ID or environment	Verify template ID in admin portal, check environment
Slow generation time	Complex template, large data	Optimize template, consider batch processing
API authentication fails	Expired or wrong credentials	Regenerate API key, verify secret

Appendix D: Contact Information

Component-Specific Contacts:

Role	Contact	Use For
Technical Architect	[Name], [Email]	Integration design, API questions
Template Specialist	[Name], [Email]	Template development, Designer issues

Support Channels:

Portal: https://support.swedwise.com
Email: support@swedwise.com
Phone: +46 54 17 11 10

Appendix E: Useful Resources

Resource	URL	Description
API Documentation	https://developers.swedwise.com	Complete API reference
Template Gallery	https://templates.swedwise.com	Sample templates and examples
Designer Knowledge Base	https://kb.swedwise.com/designer	How-to guides, best practices
Video Tutorials	https://training.swedwise.com	Step-by-step video guides
Community Forum	https://community.swedwise.com	Ask questions, share experiences

Document Control

Version	Date	Author	Changes
1.0	2025-01-15	Technical Architect	Initial version - split from combined addendum

Questions or Need Assistance?

Contact your assigned Technical Architect or email: onboarding@swedwise.com

This document is confidential and intended for use by Swedwise AB customers. Unauthorized distribution is prohibited.