Page History

Guide with complete solution lifecycle from development through production deployment.

How-to → Solution Lifecycle | Tutorial | How-to Guide | Reference

Solution Lifecycle Overview

The Three Stages

Configuration and Execution Environments

Start at Solution Center to create a new solution, or to work with an existing on.

The Three Workspaces

Development Stage

Initial Development

Creating the solution:

1. Solution Center → New Solution
2. Select appropriate template
3. Configure in Designer
4. Use Development profile

Development environment characteristics:

• Local SQLite databases
• Full diagnostic logging
• Simulation data enabled
• Unrestricted editing
• Test mode available

Development Workflow

1. Configure modules progressively:
   • Define tags and templates
   • Setup device connections
   • Create displays
   • Add business logic
2. Test incrementally:
   • Use Test Mode (F5)
   • Verify each module
   • Check integrations
   • Monitor performance
3. Version control:
   • Regular backups
   • Track changes
   • Document modifications
   • Tag development versions

Development Sprint Planning

Organize work in sprints:

• Sprint 1: UNS Foundation (P1)
• Sprint 2: Process Modules (P2)
• Sprint 3: Application Modules (P3)
• Sprint 4: User Interface (P4)
• Sprint 5: Integration & Testing

Validation Stage

Moving to Validation

Preparation steps:

1. Complete development features
2. Build solution (F6)
3. Export/backup development version
4. Create validation environment

Validation profile setup:

Validation Testing

Functional testing:

• All features work as designed
• Data flows correctly
• Alarms trigger properly
• Reports generate accurately

Performance testing:

• Load testing with real data volumes
• Stress testing communications
• Client connection limits
• Resource utilization

Integration testing:

• External system connections
• Database operations
• Third-party interfaces
• Redundancy failover

Testing Levels

• Unit Testing - Individual components
• Integration Testing - Module interactions
• System Testing - Complete solution
• Acceptance Testing - Business requirements

Validation Checklist

? All modules configured ? Scripts compile without errors ? Displays render correctly ? Communications stable ? Alarms functioning ? Historical data recording ? Security implemented ? Performance acceptable

Production Stage

Production Deployment

Pre-deployment:

1. Complete validation sign-off
2. Create production backup
3. Document configuration
4. Prepare rollback plan

Deployment steps:

1. Publish solution:

   Runtime → Publish
   Version: 1.0.0
   Type: Read-only (.dbrun)

2. Transfer to production:
   • Copy .dbrun file
   • Install on production server
   • Configure production profile
3. Production profile:

   Database: Production SQL
   Historian: Full retention
   Security: Active Directory
   Redundancy: Enabled

Production Startup

1. Stop any running solutions
2. Load production solution
3. Select Production profile
4. Start with monitoring
5. Verify all modules active
6. Check client connections
7. Confirm data flow

Version Management

Version Numbering

Standard format: Major.Minor.Build

• Major: Significant changes
• Minor: Feature additions
• Build: Bug fixes

Example progression:

1.0.0 - Initial production
1.1.0 - Added reporting module
1.1.1 - Fixed alarm bug
2.0.0 - Major upgrade

Creating Versions

Development versions:

• Auto-increment build number
• Tag with date/time
• Include developer notes

Production versions:

1. Go to Runtime → Publish
2. Set version number
3. Add release notes
4. Create .dbrun file
5. Archive with documentation

Migration Procedures

Development to Validation

1. Export from Development:
   • Build solution
   • Create backup
   • Document changes
2. Import to Validation:
   • Load in test environment
   • Switch to Validation profile
   • Update connection strings
   • Test all functions

Validation to Production

1. Prepare solution:
   • Final build
   • Publish read-only
   • Create deployment package
2. Deploy to production:
   • Schedule maintenance window
   • Backup current production
   • Install new version
   • Verify operation
   • Monitor closely

Rollback Procedures

If issues occur:

1. Stop current solution
2. Load previous .dbrun
3. Start with last known good
4. Investigate issues offline
5. Plan corrective action

Backup and Recovery

Backup Strategy

Development backups:

• Daily automatic
• Before major changes
• Keep 30 days

Production backups:

• Continuous replication
• Daily full backup
• Weekly archives
• Monthly long-term

Backup Methods

Manual backup:

1. Solution Center → Select solution
2. File → Export → Backup
3. Choose location
4. Include resources

Automatic backup:

batch

TBackup.exe /solution:"Production" /output:"D:\Backups" /daily

Recovery Procedures

From backup:

1. Solution Center → Import
2. Select .dbback file
3. Choose restore location
4. Verify integrity
5. Update configuration

From published version:

1. Locate .dbrun file
2. Copy to production
3. Start with profile
4. Verify operation

Change Management

Change Control Process

1. Request: Document change need
2. Review: Assess impact
3. Approve: Get authorization
4. Implement: Make change in Dev
5. Test: Validate in Test
6. Deploy: Move to Production
7. Verify: Confirm operation

Online Changes

Changes safe for production:

• Tag value modifications
• Display updates
• Report adjustments
• User permissions

Changes requiring restart:

• Device configurations
• Database connections
• Module additions
• Port changes

Change Documentation

Track for each change:

• Date and time
• Person responsible
• Modules affected
• Reason for change
• Test results
• Rollback plan

Best Practices

Development Phase

Use meaningful naming conventions

Comment complex logic

Test edge cases

Document assumptions

Regular commits

Validation Phase

Test with production data volumes

Verify all integrations

Check error handling

Validate performance

Document test results

Production Phase

Monitor continuously

Maintain change log

Regular backups

Plan maintenance windows

Keep documentation current

General Guidelines

Never edit production directly

Always have rollback plan

Test changes thoroughly

Document everything

Maintain version history

In this section...