External Configuration Server – Blazor Microfrontend Backlog Plan¶

Introduction¶

This document outlines the backlog planning for Blazor-based microfrontend development for the External Configuration Server (ECS) portal. The ECS microfrontend portal provides a modern, modular user interface for managing configurations, monitoring system health, and enabling self-service capabilities.

The plan leverages two templates for solution generation: * ConnectSoft.Blazor.ShellTemplate (cs-blazor-shell): For generating the Shell application that hosts and orchestrates all microfrontends. * ConnectSoft.Blazor.MicrofrontendLibraryTemplate (connectsoft-blazor-mfe): For generating individual microfrontend projects (Admin, Self-Service, Monitoring).

All repositories will be generated from these templates, ensuring consistency, best practices, and adherence to ConnectSoft architectural standards.

The plan is structured with:

Epic(s): High-level user experience capabilities to be delivered.
Features: Functional microfrontend components, each as an independent deployable unit.
Tasks: Actionable items required for implementation, including template generation, UI development, and integration.
Acceptance Criteria: Clear validation goals to ensure readiness and completeness.

This backlog focuses exclusively on the user interface layer of ECS, complementing the core service backlog plan. The microfrontends integrate with ECS backend APIs (as defined in the main backlog) and provide a cohesive user experience across different user personas (administrators, developers, operators).

Prerequisites¶

The following epics from the main Config Platform Backlog Plan must be completed or in progress before starting MFE development:

Required for Shell Application¶

ECS-Core-001 – Core Service Foundations: Basic CRUD APIs must be available for initial integration.
ECS-Auth-001 – Authentication & Authorization (if applicable): Authentication endpoints and token management.

Required for Admin Microfrontend¶

ECS-Core-001 – Core Service Foundations: Configuration CRUD APIs.
ECS-Core-VER-001 – Configuration Versioning: Version management APIs.
ECS-Gov-POL-001 – Policy Management (if applicable): Policy APIs for compliance features.
ECS-MT-001 – Multi-Tenancy (if applicable): Tenant management APIs.

Required for Self-Service Microfrontend¶

ECS-Core-001 – Core Service Foundations: Read APIs for configuration viewing.
ECS-Core-VER-001 – Configuration Versioning: Version viewing capabilities.

Required for Monitoring Microfrontend¶

ECS-Obs-MET-001 – Metrics & Telemetry: Metrics endpoints.
ECS-Obs-HEA-001 – Health Checks: Health check endpoints.
ECS-Aud-LOG-001 – Audit Logging: Audit log APIs.

Required for SDK Integration¶

ECS-SDK-001 – Client SDKs: ECS SDK must be available for integration in Blazor applications.

Template References¶

Shell Template¶

ConnectSoft.Blazor.ShellTemplate

Repository: ConnectSoft.Blazor.ShellTemplate
NuGet Package: ConnectSoft.Blazor.ShellTemplate
Template Short Name: cs-blazor-shell
Purpose: Generates a production-ready Blazor Server Shell application for hosting multiple microfrontends. Includes navigation, routing, UIKit integration, and MFE configuration.

Microfrontend Template¶

ConnectSoft.Blazor.MicrofrontendLibraryTemplate

Repository: ConnectSoft.Blazor.MicrofrontendLibraryTemplate
NuGet Package: ConnectSoft.Blazor.MicrofrontendLibrary
Template Short Name: connectsoft-blazor-mfe
Purpose: Generates individual Blazor WebAssembly microfrontend projects. Can be used for creating Admin, Self-Service, and Monitoring MFEs.

Reference Implementations¶

ConnectSoft.Blazor.Mfe.Identity.AdminTemplate

Repository: ConnectSoft.Blazor.Mfe.Identity.AdminTemplate
Purpose: Reference implementation for Admin microfrontend patterns, authentication, authorization, and CRUD operations.

ConnectSoft.Blazor.Mfe.Identity.SelfServiceTemplate

Repository: ConnectSoft.Blazor.Mfe.Identity.SelfServiceTemplate
Purpose: Reference implementation for Self-Service microfrontend patterns, user-facing dashboards, and limited edit capabilities.

Template Installation¶

Install the Shell Template¶

# Install from NuGet
dotnet new install ConnectSoft.Blazor.ShellTemplate

# Or install from local source
dotnet new install ./ConnectSoft.Blazor.ShellTemplate/template

Install the Microfrontend Template¶

# Install from NuGet
dotnet new install ConnectSoft.Blazor.MicrofrontendLibrary

# Or install from local source
dotnet new install ./ConnectSoft.Blazor.MicrofrontendLibraryTemplate

Verify Installation¶

# List installed templates
dotnet new list ConnectSoft.Blazor

# Should show:
# - cs-blazor-shell (Shell template)
# - connectsoft-blazor-mfe (Microfrontend template)

Development Workflow¶

1. Generate Shell Application¶

# Generate Shell using Shell template
dotnet new cs-blazor-shell \
  -n "Ecs.Portal.Shell" \
  -c "ConnectSoft" \
  --uiKitAdapter Flowbite \
  --includeTests true

2. Generate Individual Microfrontends¶

Each microfrontend should be generated as a separate repository using the microfrontend template:

# Generate Admin MFE
dotnet new connectsoft-blazor-mfe -n "Ecs.Portal.Admin" ...

# Generate Self-Service MFE
dotnet new connectsoft-blazor-mfe -n "Ecs.Portal.SelfService" ...

# Generate Monitoring MFE
dotnet new connectsoft-blazor-mfe -n "Ecs.Portal.Monitoring" ...

3. Development Cycle¶

Generate → Use template CLI to create solution structure
Configure → Set up ECS API endpoints, authentication, and SDK integration
Develop → Implement UI components, pages, and business logic
Test → Unit tests, integration tests, and E2E tests
Deploy → Containerize and deploy independently

4. Integration Testing¶

Test MFE integration with Shell application
Verify ECS API connectivity
Validate authentication and authorization flows
Test SDK integration and caching

Deployment Strategy¶

Independent Deployment¶

Each microfrontend is deployed as an independent Blazor WebAssembly application:

Shell Application: Blazor Server hosting MFEs
Admin MFE: Blazor WebAssembly, deployed separately
Self-Service MFE: Blazor WebAssembly, deployed separately
Monitoring MFE: Blazor WebAssembly, deployed separately

Containerization¶

Each MFE has its own Dockerfile
Container images built and published to container registry
Helm charts for Kubernetes deployment

CI/CD¶

Separate Azure Pipelines for each MFE repository
Automated testing and quality gates
Independent versioning and release cycles

Integration Points¶

ECS Backend APIs¶

All microfrontends integrate with ECS backend APIs:

Configuration APIs: /api/configs/* (from ECS-Core-001)
Version APIs: /api/configs/{id}/versions/* (from ECS-Core-VER-001)
Metrics APIs: /api/metrics/* (from ECS-Obs-MET-001)
Health APIs: /api/health/* (from ECS-Obs-HEA-001)
Audit APIs: /api/audit/* (from ECS-Aud-LOG-001)

ECS SDK Integration¶

Use ECS SDK (from ECS-SDK-001) for configuration access
Implement local caching for performance
Handle offline scenarios and retry logic
Integrate with SDK service abstraction layer

Authentication & Authorization¶

OAuth 2.0 / OpenID Connect integration
Token management and refresh
Role-based access control (RBAC)
Policy-based authorization

ECS User Experience Portal¶

Purpose: Deliver a modern, modular Blazor-based microfrontend portal for the External Configuration Server (ECS). The portal provides separate microfrontends for different user personas and use cases, all integrated through a unified Shell application.

Epic: ECS-UX-MFE-001 – Blazor Microfrontend Portal¶

Description: Deliver a comprehensive Blazor-based microfrontend portal for the External Configuration Server (ECS). This epic covers the Shell application (generated using ConnectSoft.Blazor.ShellTemplate) that hosts and orchestrates microfrontends, as well as individual microfrontends for administration, self-service, and monitoring (generated using ConnectSoft.Blazor.MicrofrontendLibraryTemplate). All components follow established patterns from reference implementations.

Acceptance Criteria:

Shell application successfully hosts and loads all microfrontends.
Navigation and routing work seamlessly across MFEs.
Authentication and authorization are integrated across all MFEs.
Each MFE can be developed, tested, and deployed independently.
All MFEs integrate with ECS backend APIs via SDK or direct HTTP calls.
Portal is accessible via web browser with responsive design.

Feature: ECS-UX-MFE-SHELL-001 – Shell Application¶

Description: Create the Blazor Server Shell application that hosts and orchestrates all ECS microfrontends. The Shell provides navigation, layout, authentication, and MFE loading capabilities.

Acceptance Criteria:

Shell application generated using cs-blazor-shell template (ConnectSoft.Blazor.ShellTemplate).
Shell successfully loads and displays all registered microfrontends.
Navigation menu provides access to all MFEs.
Authentication state is managed at Shell level and shared with MFEs.
Layout includes header, navigation, and footer components.
Shell is deployable as a standalone Blazor Server application.
MFE endpoints configured in Shell's appsettings.json under MicroFrontends section.

Tasks:

ECS-UX-MFE-SHELL-T001 – Generate Shell Application
- Install ConnectSoft.Blazor.ShellTemplate.
- Generate Shell application using cs-blazor-shell template CLI with ECS-specific parameters.
- Configure company name, UIKit adapter (Flowbite recommended), and include tests.
- Verify solution structure includes Shell project with proper Blazor Server setup.
- ✅ Acceptance: Shell solution generated and builds successfully.
ECS-UX-MFE-SHELL-T002 – Configure ECS Authentication
- Configure OAuth 2.0 / OpenID Connect for ECS authentication.
- Set up authentication state management.
- Implement token storage and refresh logic.
- ✅ Acceptance: Users can authenticate and access authenticated routes.
ECS-UX-MFE-SHELL-T003 – Implement Navigation and Layout
- Create MainLayout.razor with header, navigation menu, and footer.
- Implement navigation menu with links to all MFEs.
- Configure routing for Shell and MFE routes.
- Add home/dashboard page.
- ✅ Acceptance: Navigation menu displays all MFEs and routing works correctly.
ECS-UX-MFE-SHELL-T004 – Configure MFE Registration
- Register all ECS microfrontends in Shell configuration.
- Configure MFE loading and routing.
- Set up MFE discovery and dynamic loading.
- ✅ Acceptance: All MFEs are registered and can be loaded by Shell.
ECS-UX-MFE-SHELL-T005 – Integrate UIKit and Styling
- Configure ConnectSoft.Blazor.UIKit in Shell application.
- Set up TailwindCSS and Flowbite integration.
- Configure theme (light/dark) and brand colors.
- Add CSS references and JavaScript initialization.
- ✅ Acceptance: Shell application uses UIKit components and styling correctly.

Feature: ECS-UX-MFE-ADMIN-001 – Admin Configuration Microfrontend¶

Description: Create an Admin microfrontend for managing ECS configurations with full CRUD capabilities, version management, policy configuration, and multi-tenant management. This MFE targets administrators and power users.

Acceptance Criteria:

Admin MFE generated using template (or created within Shell solution).
Full CRUD UI for configuration management.
Version management UI with rollback capabilities.
Policy and compliance configuration UI.
Multi-tenant management UI (if applicable).
MFE integrates with ECS backend APIs.
MFE follows patterns from ConnectSoft.Blazor.Mfe.Identity.AdminTemplate.

Tasks:

ECS-UX-MFE-ADMIN-T001 – Generate Admin MFE
- Generate Admin microfrontend using template CLI or create within Shell solution.
- Configure project structure with Pages, Components, Services, and Models folders.
- Set up Blazor WebAssembly project configuration.
- ✅ Acceptance: Admin MFE project created and builds successfully.
ECS-UX-MFE-ADMIN-T002 – Implement Configuration CRUD UI
- Create configuration list page with search and filtering.
- Implement configuration create/edit form with validation.
- Add configuration detail view page.
- Implement delete functionality with confirmation.
- Integrate with ECS Configuration APIs (ECS-Core-API-001).
- ✅ Acceptance: Users can create, read, update, and delete configurations via UI.
ECS-UX-MFE-ADMIN-T003 – Build Version Management UI
- Create version list page showing all versions for a configuration.
- Implement version detail view with diff visualization.
- Add rollback functionality with confirmation.
- Integrate with ECS Version APIs (ECS-Core-VER-001).
- ✅ Acceptance: Users can view versions, compare changes, and rollback configurations.
ECS-UX-MFE-ADMIN-T004 – Implement Policy and Compliance UI
- Create policy management page for configuration policies.
- Implement compliance dashboard showing policy violations.
- Add policy assignment and enforcement UI.
- Integrate with ECS Policy APIs (ECS-Gov-POL-001, if available).
- ✅ Acceptance: Users can manage policies and view compliance status.
ECS-UX-MFE-ADMIN-T005 – Add Multi-Tenant Management UI
- Create tenant list and management page.
- Implement tenant configuration assignment UI.
- Add tenant isolation and access control UI.
- Integrate with ECS Multi-Tenancy APIs (ECS-MT-001, if available).
- ✅ Acceptance: Users can manage tenants and assign configurations (if multi-tenancy is enabled).
ECS-UX-MFE-ADMIN-T006 – Configure Authentication and Authorization
- Set up authentication state provider.
- Implement role-based access control (RBAC) with Admin policies.
- Add authorization attributes to protected pages.
- Configure token management and API authentication.
- ✅ Acceptance: Only authorized users can access Admin MFE features.

Feature: ECS-UX-MFE-SELF-001 – Self-Service Configuration Microfrontend¶

Description: Create a Self-Service microfrontend for end users and developers to view and manage their own configurations with limited edit capabilities. This MFE provides a user-friendly interface for non-administrative users.

Acceptance Criteria:

Self-Service MFE generated using template.
User configuration dashboard showing assigned configurations.
Limited edit capabilities for user-owned configurations.
Configuration viewer with search and filtering.
MFE integrates with ECS backend APIs with appropriate permissions.
MFE follows patterns from ConnectSoft.Blazor.Mfe.Identity.SelfServiceTemplate.

Tasks:

ECS-UX-MFE-SELF-T001 – Generate Self-Service MFE
- Generate Self-Service microfrontend using template CLI or create within Shell solution.
- Configure project structure with Pages, Components, Services, and Models folders.
- Set up Blazor WebAssembly project configuration.
- ✅ Acceptance: Self-Service MFE project created and builds successfully.
ECS-UX-MFE-SELF-T002 – Implement User Configuration Dashboard
- Create dashboard page showing user's assigned configurations.
- Implement configuration cards/list view with key information.
- Add search and filtering capabilities.
- Integrate with ECS Configuration APIs with user-scoped queries.
- ✅ Acceptance: Users can view their assigned configurations in a dashboard.
ECS-UX-MFE-SELF-T003 – Build Configuration Viewer
- Create configuration detail view page.
- Implement configuration value display with syntax highlighting (if applicable).
- Add version history viewer for user-owned configurations.
- Integrate with ECS Configuration and Version APIs.
- ✅ Acceptance: Users can view configuration details and version history.
ECS-UX-MFE-SELF-T004 – Implement Limited Edit Capabilities
- Create configuration edit form for user-owned configurations.
- Implement validation and error handling.
- Add save and cancel functionality.
- Integrate with ECS Configuration APIs with appropriate permissions.
- ✅ Acceptance: Users can edit their own configurations with proper validation.
ECS-UX-MFE-SELF-T005 – Configure Authentication and Authorization
- Set up authentication state provider.
- Implement user-scoped data access.
- Add authorization checks for edit operations.
- Configure token management and API authentication.
- ✅ Acceptance: Users can only access and edit their own configurations.

Feature: ECS-UX-MFE-MON-001 – Monitoring and Observability Microfrontend¶

Description: Create a Monitoring microfrontend for operators and administrators to view ECS system health, metrics, audit logs, and alerts. This MFE provides observability capabilities for the ECS platform.

Acceptance Criteria:

Monitoring MFE generated using template.
Metrics dashboards showing key ECS metrics.
Health check visualization with status indicators.
Audit log viewer with search and filtering.
Alert management UI for configuration and system alerts.
MFE integrates with ECS Observability APIs.

Tasks:

ECS-UX-MFE-MON-T001 – Generate Monitoring MFE
- Generate Monitoring microfrontend using template CLI or create within Shell solution.
- Configure project structure with Pages, Components, Services, and Models folders.
- Set up Blazor WebAssembly project configuration.
- ✅ Acceptance: Monitoring MFE project created and builds successfully.
ECS-UX-MFE-MON-T002 – Implement Metrics Dashboards
- Create metrics dashboard page with key ECS metrics.
- Implement charts and graphs for visualization (using charting library).
- Add time range selection and filtering.
- Integrate with ECS Metrics APIs (ECS-Obs-MET-001).
- ✅ Acceptance: Users can view ECS metrics in interactive dashboards.
ECS-UX-MFE-MON-T003 – Build Health Check Visualization
- Create health check status page.
- Implement health check indicators for ECS services.
- Add detailed health check information view.
- Integrate with ECS Health Check APIs (ECS-Obs-HEA-001).
- ✅ Acceptance: Users can view ECS system health status.
ECS-UX-MFE-MON-T004 – Implement Audit Log Viewer
- Create audit log list page with search and filtering.
- Implement audit log detail view.
- Add filtering by user, action, timestamp, and configuration.
- Integrate with ECS Audit Log APIs (ECS-Aud-LOG-001).
- ✅ Acceptance: Users can search and view audit logs.
ECS-UX-MFE-MON-T005 – Add Alert Management UI
- Create alert list page showing active and resolved alerts.
- Implement alert detail view with configuration and resolution information.
- Add alert filtering and sorting capabilities.
- Integrate with ECS Alert APIs (if available).
- ✅ Acceptance: Users can view and manage ECS alerts.
ECS-UX-MFE-MON-T006 – Configure Real-Time Updates
- Implement SignalR or polling for real-time metrics updates.
- Add real-time health check status updates.
- Configure real-time alert notifications.
- ✅ Acceptance: Monitoring dashboards update in real-time.

Feature: ECS-UX-MFE-SDK-001 – ECS SDK Integration in MFEs¶

Description: Integrate the ECS SDK into all microfrontends for configuration access, local caching, error handling, and retry logic. This feature ensures consistent SDK usage across all MFEs.

Acceptance Criteria:

ECS SDK is configured in all MFEs.
Local caching is implemented for performance.
Error handling and retry logic are consistent across MFEs.
SDK service abstraction layer is implemented.
Offline scenarios are handled gracefully.

Tasks:

ECS-UX-MFE-SDK-T001 – Configure ECS SDK in All MFEs
- Add ECS SDK NuGet package to all MFE projects.
- Configure SDK client with ECS API endpoints.
- Set up SDK dependency injection in each MFE.
- ✅ Acceptance: ECS SDK is configured and accessible in all MFEs.
ECS-UX-MFE-SDK-T002 – Implement Local Caching
- Configure SDK caching for configuration data.
- Implement cache invalidation strategies.
- Add cache expiration and refresh logic.
- ✅ Acceptance: Configuration data is cached locally and refreshed appropriately.
ECS-UX-MFE-SDK-T003 – Add Error Handling and Retry Logic
- Implement consistent error handling across all MFEs.
- Add retry logic for transient failures.
- Implement circuit breaker pattern for resilience.
- Add user-friendly error messages.
- ✅ Acceptance: MFEs handle errors gracefully with retry and user feedback.
ECS-UX-MFE-SDK-T004 – Implement SDK Service Abstraction
- Create service abstraction layer for ECS SDK operations.
- Implement interfaces for configuration, version, and metrics access.
- Add service implementations using ECS SDK.
- Configure dependency injection for service abstractions.
- ✅ Acceptance: All MFEs use consistent service abstraction for ECS operations.
ECS-UX-MFE-SDK-T005 – Handle Offline Scenarios
- Implement offline detection.
- Add offline data access using cached data.
- Implement sync logic when connection is restored.
- Add offline indicators in UI.
- ✅ Acceptance: MFEs work offline using cached data and sync when online.

Feature: ECS-UX-MFE-DEP-001 – MFE Deployment and CI/CD¶

Description: Containerize all microfrontends, create deployment configurations, and set up CI/CD pipelines for independent deployment of each MFE.

Acceptance Criteria:

All MFEs are containerized with Dockerfiles.
Helm charts are created for Kubernetes deployment.
CI/CD pipelines are configured for each MFE repository.
Environment-specific settings are externalized.
Deployment documentation is available.

Tasks:

ECS-UX-MFE-DEP-T001 – Containerize All MFEs
- Create Dockerfile for Shell application.
- Create Dockerfiles for each microfrontend (Admin, Self-Service, Monitoring).
- Configure multi-stage builds for optimization.
- Add .dockerignore files.
- ✅ Acceptance: All MFEs can be built as container images.
ECS-UX-MFE-DEP-T002 – Create Helm Charts
- Create Helm chart for Shell application.
- Create Helm charts for each microfrontend.
- Configure values files for different environments.
- Add ingress and service configurations.
- ✅ Acceptance: All MFEs can be deployed to Kubernetes using Helm.
ECS-UX-MFE-DEP-T003 – Set Up CI/CD Pipelines
- Create Azure Pipeline for Shell application.
- Create Azure Pipelines for each microfrontend repository.
- Configure build, test, and deployment stages.
- Add quality gates and approval processes.
- ✅ Acceptance: CI/CD pipelines build, test, and deploy all MFEs.
ECS-UX-MFE-DEP-T004 – Configure Environment-Specific Settings
- Externalize ECS API endpoints per environment.
- Configure authentication settings per environment.
- Set up feature flags for environment-specific features.
- Add configuration management for different deployment targets.
- ✅ Acceptance: MFEs can be configured for different environments (dev, staging, prod).
ECS-UX-MFE-DEP-T005 – Create Deployment Documentation
- Document deployment process for Shell application.
- Document deployment process for each microfrontend.
- Add troubleshooting guide.
- Document rollback procedures.
- ✅ Acceptance: Complete deployment documentation is available.

CLI Commands Reference¶

Template Installation¶

Install Shell Template¶

# Install from NuGet
dotnet new install ConnectSoft.Blazor.ShellTemplate

# Install from local source
dotnet new install ./ConnectSoft.Blazor.ShellTemplate/template

Install Microfrontend Template¶

# Install from NuGet
dotnet new install ConnectSoft.Blazor.MicrofrontendLibrary

# Install from local source
dotnet new install ./ConnectSoft.Blazor.MicrofrontendLibraryTemplate

Shell Application Generation¶

# Generate Shell using Shell template
dotnet new cs-blazor-shell \
  -n "Ecs.Portal.Shell" \
  -c "ConnectSoft" \
  --uiKitAdapter Flowbite \
  --includeTests true

Available Shell Template Parameters: - -n / --name: Project name - -c / --company: Company name for assembly info - -ua / --uiKitAdapter: UIKit adapter (Tokens, Flowbite, DaisyUI) - default: Flowbite - -in / --includeTests: Include unit test project (true/false) - default: true - -f / --Framework: Target framework (net9.0) - default: net9.0

Microfrontend Generation¶

# Generate individual microfrontend
dotnet new connectsoft-blazor-mfe \
  -n "Ecs.Portal.Admin" \
  --CompanyName "ConnectSoft" \
  --ProjectName "Ecs"

Verify Template Installation¶

# List installed templates
dotnet new list ConnectSoft.Blazor

# Should show:
# - cs-blazor-shell (Shell template)
# - connectsoft-blazor-mfe (Microfrontend template)

# Uninstall templates (if needed)
dotnet new uninstall ConnectSoft.Blazor.ShellTemplate
dotnet new uninstall ConnectSoft.Blazor.MicrofrontendLibrary

Notes¶

Shell Application: Must be generated using ConnectSoft.Blazor.ShellTemplate (short name: cs-blazor-shell). The Shell template provides a production-ready Blazor Server application specifically designed for hosting multiple microfrontends.
Microfrontends: Individual MFEs should be generated using ConnectSoft.Blazor.MicrofrontendLibraryTemplate (short name: connectsoft-blazor-mfe) or created as Blazor WebAssembly projects following the same patterns.
Reference Implementations: Admin and Self-Service templates should be consulted for patterns and best practices when developing ECS-specific MFEs.
Independent Development: Each MFE can be developed and deployed independently, enabling parallel development and faster iteration.
Shell as Host: The Shell application serves as the host and orchestrator for all MFEs, providing navigation, layout, and shared services.
Authentication: Authentication and authorization are managed at the Shell level and shared with MFEs through authentication state.
Configuration: MFE endpoints and settings are configured in the Shell's appsettings.json under the MicroFrontends section.

Last Updated: 2025-01-XX
Status: Planning
Owner: ECS Platform Team

External Configuration Server – Blazor Microfrontend Backlog Plan¶

Introduction¶

Prerequisites¶

Required for Shell Application¶

Required for Admin Microfrontend¶

Required for Self-Service Microfrontend¶

Required for Monitoring Microfrontend¶

Required for SDK Integration¶

Template References¶

Shell Template¶

Microfrontend Template¶

Reference Implementations¶

Template Installation¶

Install the Shell Template¶

Install the Microfrontend Template¶

Verify Installation¶

Development Workflow¶

1. Generate Shell Application¶

2. Generate Individual Microfrontends¶

3. Development Cycle¶

4. Integration Testing¶

Deployment Strategy¶

Independent Deployment¶

Containerization¶

CI/CD¶

Integration Points¶

ECS Backend APIs¶

ECS SDK Integration¶

Authentication & Authorization¶

ECS User Experience Portal¶

Epic: ECS-UX-MFE-001 – Blazor Microfrontend Portal¶

Feature: ECS-UX-MFE-SHELL-001 – Shell Application¶

Feature: ECS-UX-MFE-ADMIN-001 – Admin Configuration Microfrontend¶

Feature: ECS-UX-MFE-SELF-001 – Self-Service Configuration Microfrontend¶

Feature: ECS-UX-MFE-MON-001 – Monitoring and Observability Microfrontend¶

Feature: ECS-UX-MFE-SDK-001 – ECS SDK Integration in MFEs¶

Feature: ECS-UX-MFE-DEP-001 – MFE Deployment and CI/CD¶

CLI Commands Reference¶

Template Installation¶

Install Shell Template¶

Install Microfrontend Template¶

Shell Application Generation¶

Microfrontend Generation¶

Verify Template Installation¶

Related Documentation¶

Notes¶