ConnectSoft Marketing Website - Development Backlog Plan¶
Overview¶
This document provides a comprehensive development backlog plan for the ConnectSoft corporate marketing website, structured as one Epic with Features and Tasks. The plan is designed for Azure DevOps Boards tracking and follows ConnectSoft engineering standards.
Repository: ConnectSoft.MarketingSite
Tech Stack: .NET 9, Blazor Web App (SSR), Tailwind CSS, Flowbite, IStringLocalizer/.resx, Azure App Service/Container Apps (Pulumi), Application Insights
Work Item Structure¶
graph TD
Epic1[MKT-WEB-EPIC-001<br/>Marketing Site v1] --> F1[MKT-WEB-FEAT-001<br/>Solution Foundation]
Epic1 --> F2[MKT-WEB-FEAT-002<br/>Azure Infrastructure + CI/CD]
Epic1 --> F3[MKT-WEB-FEAT-003<br/>Global Site Shell]
Epic1 --> F4[MKT-WEB-FEAT-004<br/>Localization EN/HE]
Epic1 --> F5[MKT-WEB-FEAT-005<br/>RTL Support Hebrew]
Epic1 --> F6[MKT-WEB-FEAT-006<br/>Pages Set A]
Epic1 --> F7[MKT-WEB-FEAT-007<br/>Pages Set B]
Epic1 --> F8[MKT-WEB-FEAT-008<br/>Pricing FAQ Legal]
Epic1 --> F9[MKT-WEB-FEAT-009<br/>Contact Form Pipeline]
Epic1 --> F10[MKT-WEB-FEAT-010<br/>SEO Analytics Launch]
Epic1 --> F11[MKT-WEB-FEAT-011<br/>Shell Template Improvements]
Epic1 --> F12[MKT-WEB-FEAT-012<br/>UIKit Improvements]
F1 --> T1[MKT-WEB-TASK-001]
F1 --> T14[MKT-WEB-TASK-014]
F1 --> T17[MKT-WEB-TASK-017]
F1 --> T18[MKT-WEB-TASK-018]
F1 --> T19[MKT-WEB-TASK-019]
F1 --> T20[MKT-WEB-TASK-020]
F1 --> T21[MKT-WEB-TASK-021]
F1 --> T22[MKT-WEB-TASK-022]
F1 --> T23[MKT-WEB-TASK-023]
F1 --> T24[MKT-WEB-TASK-024]
F2 --> T2[MKT-WEB-TASK-002]
F3 --> T3[MKT-WEB-TASK-003]
F3 --> T15[MKT-WEB-TASK-015]
F4 --> T4[MKT-WEB-TASK-004]
F5 --> T5[MKT-WEB-TASK-005]
F6 --> T6[MKT-WEB-TASK-006]
F6 --> T13[MKT-WEB-TASK-013]
F7 --> T7[MKT-WEB-TASK-007]
F8 --> T8[MKT-WEB-TASK-008]
F9 --> T9[MKT-WEB-TASK-009]
F10 --> T10[MKT-WEB-TASK-010]
F10 --> T16[MKT-WEB-TASK-016]
F11 --> T11[MKT-WEB-TASK-011]
F12 --> T12[MKT-WEB-TASK-012]
Epic2[MKT-TPL-EPIC-001<br/>Marketing Site Template] --> F13[MKT-TPL-FEAT-001<br/>Template Structure]
Epic2 --> F14[MKT-TPL-FEAT-002<br/>Template Parameters]
Epic2 --> F15[MKT-TPL-FEAT-003<br/>Template Packaging]
Epic2 --> F16[MKT-TPL-FEAT-004<br/>Template Documentation]
Epic2 --> F17[MKT-TPL-FEAT-005<br/>CI/CD for Template]
F13 --> T17[MKT-TPL-TASK-001]
F14 --> T18[MKT-TPL-TASK-002]
F15 --> T19[MKT-TPL-TASK-003]
F16 --> T20[MKT-TPL-TASK-004]
F17 --> T21[MKT-TPL-TASK-005]Epic: MKT-WEB-EPIC-001¶
Title: ConnectSoft Marketing Site v1 (Engineering Delivery) — .NET 9/Blazor/Flowbite — EN/HE (LTR/RTL)
Description: Implement the production marketing site end-to-end, using approved design as input (design work is out of scope). Deliver a fully localized (English LTR + Hebrew RTL), responsive, production-grade marketing website with all required pages, SEO baseline, analytics, and secure contact form submission.
Definition of Done: - Production deployment live with HTTPS + domain - EN + HE fully supported (LTR/RTL) - All pages live and responsive (mobile/tablet/desktop) - SEO baseline complete (metadata, OG tags, sitemap.xml, robots.txt, canonical URLs, hreflang) - Analytics + error monitoring enabled (GA4/Application Insights) - Contact form works end-to-end with spam protection and secure secret handling - Runbook documented for releases and content updates - Figma design implemented and integrated (when design files are available)
Tags: connectsoft, marketing-site, web, dotnet, blazor, flowbite, azure, devops, i18n, rtl, launch
Feature 1: MKT-WEB-FEAT-001 - Solution/Repo Foundation + Engineering Baseline¶
Description: Initialize .NET 9 Blazor Web App solution with production-ready engineering baseline, structured for marketing site delivery with quality gates and environment configuration.
Tags: connectsoft, marketing-site, web, dotnet, blazor, flowbite, foundation, ci
Task: MKT-WEB-TASK-001¶
Title: Initialize .NET 9 Blazor solution with production-ready engineering baseline (end-to-end)
Description: Create repository and baseline for Blazor Web App with SSR using .NET 9, structured for marketing site delivery, with quality gates and environment configuration. Use ConnectSoft.Blazor.ShellTemplate as starting point and integrate ConnectSoft.Blazor.UIKit with Flowbite adapter. Establish standard project structure, configure linting/formatting, set up basic test project, and implement secure configuration model.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Solution builds cleanly in Release configuration - Tailwind pipeline working; Flowbite integrated and rendering correctly - Standard project structure established (Pages/Components/Resources/Content/Infrastructure) - Linting/formatting conventions documented and enforced in CI (StyleCop, EditorConfig) - Basic test project included (smoke tests at minimum) and runs in CI - Secure configuration model (no secrets in repo; environment variable validation) - ConnectSoft.Blazor.UIKit with Flowbite adapter integrated and working - Project references ConnectSoft.Blazor.ShellTemplate patterns where applicable - .NET 9 SDK used throughout
Implementation Notes: - Prefer Blazor Web App with SSR for SEO; use InteractiveServer render mode where needed - Tailwind + Flowbite: ensure bundling/minification and JS initialization approach for Flowbite components - Follow ConnectSoft engineering standards from ConnectSoft.Documentation - Structure: Pages/, Components/, Resources/, Content/, Infrastructure/, wwwroot/ - Include Directory.Build.props and Directory.Packages.props for consistent package management - Use .NET 9 features where beneficial
Tags: connectsoft, marketing-site, web, dotnet, blazor, flowbite, foundation, ci
Task: MKT-WEB-TASK-014¶
Title: Configure security headers end-to-end (CSP, HSTS, X-Frame-Options, etc.)
Description: Configure production-grade security headers including Content Security Policy (CSP), Strict-Transport-Security (HSTS), X-Frame-Options, X-Content-Type-Options, Referrer-Policy, and Permissions-Policy. Ensure headers are compatible with Blazor SSR, Tailwind CSS, Flowbite, and SignalR requirements. Configure different policies for development and production environments.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Security headers middleware configured and active - Content Security Policy (CSP) configured with nonce support for Blazor - CSP allows Tailwind CSS and Flowbite components to function correctly - Strict-Transport-Security (HSTS) enabled for production - X-Frame-Options, X-Content-Type-Options, Referrer-Policy configured - Permissions-Policy configured to restrict unnecessary browser features - Security headers tested in both development and production environments - Headers verified using security header testing tools - Documentation includes security header configuration rationale
Implementation Notes: - Use NetEscapades.AspNetCore.SecurityHeaders or similar library - Configure CSP with nonce support for Blazor inline scripts - Allow necessary external resources (fonts, CDN) in CSP while maintaining security - Use environment-specific policies (more permissive in dev, strict in prod) - Reference ConnectSoft security header patterns from other projects - Test with browser developer tools and security header analyzers
Tags: security, headers, csp, hsts, foundation, blazor
Task: MKT-WEB-TASK-017¶
Title: Configure Options Pattern and AppSettings Validation end-to-end
Description:
Implement Options pattern with IValidateOptions for strongly-typed configuration management. Create options classes (MarketingSiteOptions, ValidationOptions, RateLimitingOptions, LoggingOptions, ObservabilityOptions) with validation, configure appsettings.json structure, and use IOptions
Repository: ConnectSoft.MarketingSite
Acceptance Criteria:
- Options pattern implemented with IOptions
Implementation Notes:
- Follow ConnectSoft.MicroserviceTemplate Options pattern from OptionsExtensions.cs
- Use IValidateOptions
Tags: options, configuration, validation, foundation, connectsoft
Task: MKT-WEB-TASK-018¶
Title: Implement Serilog Structured Logging end-to-end
Description: Configure Serilog as the primary logging provider with structured logging capabilities. Set up Serilog configuration via appsettings.json, implement request logging middleware, configure sinks (Console, Application Insights), enable log enrichment (request path, method, status code, correlation ID, user context), and integrate with ASP.NET Core logging infrastructure.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Serilog configured as primary logging provider - Serilog configuration loaded from appsettings.json (Serilog section) - Request logging middleware implemented with enrichment - Console sink configured for development - Application Insights sink configured for production - Log enrichment includes request path, method, status code, correlation ID, user context - Structured logging format used throughout application - Log levels configured appropriately for development and production - Serilog request logging excludes health check endpoints (if applicable) - Logs are properly formatted and searchable in Application Insights
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate Serilog pattern from SerilogLoggingExtensions.cs - Use Serilog.AspNetCore for ASP.NET Core integration - Configure Serilog via appsettings.json (ReadFrom.Configuration) - Use UseSerilogRequestLogging() middleware for HTTP request logging - Enable log enrichment in EnrichDiagnosticContext callback - Configure different log levels for development vs production - Use structured logging with properties (not string interpolation) - Reference ConnectSoft.MicroserviceTemplate Serilog configuration patterns - Ensure compatibility with Blazor SSR and SignalR if used
Tags: logging, serilog, structured-logging, observability, foundation
Task: MKT-WEB-TASK-019¶
Title: Configure OpenTelemetry Observability end-to-end
Description: Set up OpenTelemetry for distributed tracing and metrics collection. Configure OpenTelemetry tracing and metrics instrumentation, set up Application Insights exporter, add ASP.NET Core and HTTP client instrumentation, configure resource attributes (service name, version, environment), and ensure traces and metrics are exported to Application Insights.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - OpenTelemetry configured with tracing and metrics - Application Insights exporter configured and functional - ASP.NET Core instrumentation enabled (requests, dependencies, exceptions) - HTTP client instrumentation enabled for outbound calls - Resource attributes configured (service.name, service.version, deployment.environment) - Traces exported to Application Insights successfully - Metrics exported to Application Insights successfully - OpenTelemetry configuration loaded from options/configuration - Distributed tracing works across service boundaries (if applicable) - Performance overhead is acceptable in production
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate OpenTelemetry pattern from OpenTelemetryExtensions.cs - Use OpenTelemetry.Exporter.AzureMonitor or Application Insights exporter - Configure OpenTelemetry resource attributes for service identification - Add ASP.NET Core instrumentation (AspNetCoreInstrumentation) - Add HTTP client instrumentation (HttpClientInstrumentation) - Configure OpenTelemetry options via configuration (OpenTelemetryOptions) - Reference ConnectSoft.MicroserviceTemplate OpenTelemetry configuration - Ensure OpenTelemetry works with Blazor SSR - Consider OpenTelemetry Collector if needed for complex scenarios
Tags: observability, opentelemetry, tracing, metrics, application-insights, foundation
Task: MKT-WEB-TASK-020¶
Title: Implement FluentValidation Infrastructure end-to-end
Description: Set up FluentValidation framework for model validation. Register FluentValidation services, configure validation options (cascade mode, fail-fast behavior), set up validator scanning/discovery, and prepare infrastructure for integration with contact form (MKT-WEB-TASK-009) and other form submissions.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - FluentValidation services registered in DI container - Validator scanning/discovery configured (assembly scanning) - Validation options configured (cascade mode, fail-fast behavior) - ValidationOptions from configuration respected - Validators can be discovered and registered automatically - FluentValidation integrated with ASP.NET Core model validation - Validation error messages are properly formatted - Infrastructure ready for contact form validation (TASK-009) - Validators follow ConnectSoft validation patterns
Implementation Notes:
- Follow ConnectSoft.MicroserviceTemplate FluentValidation pattern from FluentValidationExtensions.cs
- Use FluentValidation.AspNetCore for ASP.NET Core integration
- Configure validator scanning to discover validators from assembly
- Set up cascade mode configuration (class-level and rule-level)
- Configure fail-fast behavior via ValidationOptions
- Use IValidator
Tags: validation, fluentvalidation, forms, foundation
Task: MKT-WEB-TASK-021¶
Title: Configure Rate Limiting end-to-end
Description: Implement ASP.NET Core rate limiting middleware to protect endpoints from abuse. Configure global rate limiter (per IP address), set up rate limiting options via appsettings, implement enable/disable via configuration, and ensure rate limiting works correctly with Blazor SSR and API endpoints.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Rate limiting middleware configured and active - Global rate limiter implemented (per IP address partitioning) - Rate limiting options configured via appsettings.json - Rate limiting can be enabled/disabled via configuration - Rate limiting returns 429 Too Many Requests when limit exceeded - IP address extraction works correctly (handles proxies, X-Forwarded-For) - Rate limiting policies configured via options - Rate limiting works with Blazor SSR endpoints - Rate limiting tested and verified in development and production - Configuration options documented
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate rate limiting pattern from RateLimitingExtensions.cs - Use Microsoft.AspNetCore.RateLimiting middleware - Configure FixedWindowRateLimiter or SlidingWindowRateLimiter - Partition rate limiter by IP address (handle X-Forwarded-For headers) - Configure rate limiting options via RateLimitingOptions - Enable/disable via configuration flag - Set appropriate permit limits and window sizes - Reference ConnectSoft.MicroserviceTemplate rate limiting configuration - Test rate limiting with different scenarios (burst traffic, sustained traffic) - Consider per-endpoint policies if needed (e.g., stricter limits for contact form)
Tags: rate-limiting, security, performance, middleware, foundation
Task: MKT-WEB-TASK-022¶
Title: Configure CORS Policies end-to-end
Description: Set up CORS (Cross-Origin Resource Sharing) middleware with named policies. Configure default CORS policy for development, set up production CORS policies via appsettings, and ensure CORS works correctly with Blazor SSR and any API endpoints.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - CORS middleware configured and active - Default CORS policy configured for development - Named CORS policies configured (if needed) - Production CORS policies configured via appsettings - CORS policies allow necessary origins, methods, and headers - CORS works correctly with Blazor SSR - CORS preflight requests handled correctly - CORS configuration tested and verified - CORS policies follow security best practices
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate CORS pattern from CorsExtensions.cs - Use Microsoft.AspNetCore.Cors middleware - Configure default policy for development (localhost origins) - Configure production policies via appsettings (specific origins) - Set appropriate allowed methods (GET, POST, etc.) - Configure allowed headers as needed - Consider credentials policy if needed - Reference ConnectSoft.MicroserviceTemplate CORS configuration - For marketing site, CORS may be minimal (same-origin typically) - Document CORS policy rationale
Tags: cors, security, middleware, foundation
Task: MKT-WEB-TASK-023¶
Title: Configure Header Propagation end-to-end
Description: Set up header propagation middleware for distributed tracing and correlation. Configure header propagation for correlation/trace headers (X-Correlation-Id, X-TraceId, traceparent), set up HTTP client integration for outbound calls, and ensure headers are properly propagated across service boundaries.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Header propagation middleware configured and active - Correlation headers configured (X-Correlation-Id, X-TraceId, traceparent) - Header propagation integrated with HTTP client factory - Headers are propagated on outbound HTTP calls - Headers are received and propagated on inbound requests - Header propagation works with distributed tracing - Configuration options documented - Header propagation tested and verified
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate header propagation pattern from HeaderPropagationExtensions.cs - Use Microsoft.AspNetCore.HeaderPropagation middleware - Configure headers to propagate (X-Correlation-Id, X-TraceId, traceparent) - Integrate with IHttpClientFactory for automatic header propagation - Use AddHeaderPropagation() and UseHeaderPropagation() extension methods - Reference ConnectSoft.MicroserviceTemplate header propagation configuration - Header propagation enables distributed tracing correlation - Consider if header propagation is needed for marketing site (may be minimal for single-site)
Tags: header-propagation, distributed-tracing, correlation, middleware, foundation
Task: MKT-WEB-TASK-024¶
Title: Implement Metrics Infrastructure end-to-end
Description: Set up System.Diagnostics.Metrics infrastructure for application metrics collection. Configure metrics collection (counter, histogram, gauge), register marketing site-specific metrics, export metrics to Application Insights, and ensure metrics are properly collected and available for monitoring.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - System.Diagnostics.Metrics infrastructure configured - Metrics collection enabled (counter, histogram, gauge instruments) - Marketing site metrics registered (page views, form submissions, errors, etc.) - Metrics exported to Application Insights - Metrics are properly tagged/labeled for querying - Metrics collection has acceptable performance overhead - Metrics infrastructure follows ConnectSoft patterns - Metrics documented (what is tracked, how to query)
Implementation Notes: - Follow ConnectSoft.MicroserviceTemplate metrics pattern from MicroserviceMetricsExtensions.cs - Use System.Diagnostics.Metrics for .NET metrics - Create metrics classes for marketing site (MarketingSiteMetrics) - Register metrics in DI container - Export metrics via OpenTelemetry to Application Insights - Define relevant metrics for marketing site (requests, form submissions, errors, performance) - Use Counter, Histogram, Gauge instruments as appropriate - Reference ConnectSoft.MicroserviceTemplate metrics patterns - Ensure metrics are properly tagged for filtering and aggregation - Document metrics schema and usage
Tags: metrics, observability, monitoring, application-insights, foundation
Feature 2: MKT-WEB-FEAT-002 - Azure Infrastructure + CI/CD (Dev/Stage/Prod) End-to-End¶
Description: Provision Azure hosting infrastructure using Pulumi and establish CI/CD pipeline for dev/stage/prod environments with secure secret management.
Tags: azure, devops, cicd, infrastructure, connectsoft, launch, pulumi
Task: MKT-WEB-TASK-002¶
Title: Provision Azure hosting + CI/CD pipeline + domain/HTTPS for dev/stage/prod end-to-end (Pulumi)
Description: Define and deploy Azure infrastructure using Pulumi for chosen hosting option (App Service or Container Apps), create comprehensive Azure DevOps pipeline with lint/build/test/publish/deploy stages, configure environment-specific settings, implement secure secret management, establish deployment workflows for all environments, bind custom domain to production, enable HTTPS with SSL certificate management, and configure redirects (www/non-www, trailing slash policy).
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Azure infrastructure defined using Pulumi (C#) for chosen hosting (App Service or Container Apps) - Azure DevOps pipeline includes comprehensive stages: lint, build, test, publish, deploy - Lint stage: code analysis, formatting checks, StyleCop validation - Build stage: solution build in Release configuration - Test stage: unit tests, integration tests (if applicable), code coverage reporting - Publish stage: artifact creation and publishing - Deploy stage: deployment to dev/stage/prod environments - Separate environments (dev/stage/prod) with approvals for prod - Secrets managed via Key Vault / pipeline variable groups (secured, no plaintext) - Code quality gates configured (code coverage threshold, test execution) - Test results and code coverage reports published as artifacts - Deployment outputs a reachable URL per environment - Infrastructure choice documented (App Service vs Container Apps rationale) - Pulumi stacks configured for dev/stage/prod - Infrastructure code follows ConnectSoft Pulumi patterns - Domain bound to prod environment - HTTPS enabled and enforced (HTTP -> HTTPS redirect) - Redirects configured (www/non-www canonicalization, trailing slash policy) - SSL certificate managed (Let's Encrypt or Azure-managed) - Redirect strategy documented
Implementation Notes: - Use Pulumi with C# (.NET) following ConnectSoft InfrastructureModel patterns - Use Azure DevOps pipeline templates from ConnectSoft standards (reference ConnectSoft.MicroserviceTemplate azure-pipelines.yml structure) - Follow ConnectSoft pipeline template patterns (build/lint-microservice-steps.yaml, build/build-microservice-steps.yaml, test/test-microservice-steps.yaml, publish/publish-microservice-steps.yaml) - Include code coverage threshold and quality gates - Key Vault integration for secrets - Environment-specific app settings via configuration - Reference ConnectSoft.Documentation infrastructure patterns - Use Azure Front Door if needed for CDN/global distribution; otherwise App Service domain bindings - Consider Azure App Service Managed Certificates or Key Vault for SSL
Tags: azure, devops, cicd, infrastructure, connectsoft, launch, pulumi, domain, https
Feature 3: MKT-WEB-FEAT-003 - Global Site Shell + Navigation + Responsive Layout¶
Description: Implement global layout shell (header/nav/footer) with responsive design, accessibility, and consistent Tailwind/Flowbite styling.
Tags: layout, navigation, accessibility, flowbite, blazor
Task: MKT-WEB-TASK-003¶
Title: Implement global layout shell end-to-end (header/nav/footer, responsive, accessible)
Description: Build responsive header with mobile navigation, footer with key links including Legal pages and language switcher, ensuring keyboard navigation and focus states pass basic accessibility checks. Implement reusable layout components and ensure RTL-friendly CSS.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Responsive header with mobile navigation (hamburger menu on mobile) - Footer includes all key links (Home, Services, About, Contact, Legal links, language switch) - Keyboard navigation and focus states pass basic accessibility checks (WCAG 2.1 AA baseline) - All UI elements use Tailwind/Flowbite styling consistently - Mobile-first responsive design verified (mobile/tablet/desktop breakpoints) - Layout components are reusable and maintainable - RTL-friendly CSS implemented (logical properties where possible)
Implementation Notes: - Prefer reusable layout components (MainLayout.razor, Header.razor, Footer.razor) - Ensure RTL-friendly CSS (logical properties where possible, test with Hebrew) - Use ConnectSoft.Blazor.UIKit components where applicable (Button, Navigation components) - Test with screen reader and keyboard-only navigation
Tags: layout, navigation, accessibility, flowbite, blazor
Task: MKT-WEB-TASK-015¶
Title: Implement error pages end-to-end (404 Not Found, 500 Server Error)
Description: Implement user-friendly error pages for 404 Not Found and 500 Server Error scenarios with full EN/HE localization, RTL support, consistent branding, and helpful navigation options. Configure error handling middleware and ensure error pages are properly integrated with the application routing and layout system.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - 404 Not Found page implemented with EN/HE localization and RTL support - 500 Server Error page implemented with EN/HE localization and RTL support - Error pages use consistent branding and styling (Tailwind/Flowbite) - Error pages include helpful navigation options (return to home, search, contact) - Error handling middleware configured (UseExceptionHandler for production) - Error pages are accessible (keyboard navigation, screen reader support) - 404 page provides suggestions or search functionality where appropriate - Error pages include proper HTTP status codes - Error logging implemented for 500 errors (logged to Application Insights) - Error pages tested in both development and production modes
Implementation Notes: - Use Blazor error handling patterns (NotFound component in App.razor Router) - Configure UseExceptionHandler middleware for production error handling - Ensure error pages are consistent with site design and layout - Include helpful messages and navigation options - Use structured logging for server errors (do not expose sensitive information to users) - Test error scenarios (invalid routes, server errors)
Tags: error-pages, 404, 500, layout, accessibility, i18n, rtl
Feature 4: MKT-WEB-FEAT-004 - Localization (EN/HE) + Routing + Language Persistence¶
Description: Implement English and Hebrew localization across the application with culture switching and preference persistence.
Tags: i18n, localization, dotnet, blazor, connectsoft
Task: MKT-WEB-TASK-004¶
Title: Implement EN/HE localization end-to-end across the app
Description: Set up localization infrastructure using IStringLocalizer/.resx resources for English and Hebrew, implement language switcher with culture persistence (cookie-based), configure culture routing, and ensure all shared UI text is localized with no hard-coded strings remaining.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - EN and HE resources implemented with IStringLocalizer/.resx (or equivalent pattern) - Language switcher changes culture and persists preference (cookie-based) - All shared UI text localized (nav, footer, buttons, form labels, validation messages) - No hard-coded visible strings remain in shared layout/components - Culture routing works (e.g., /en/home, /he/home or query parameter approach) - Language preference persists across page navigation - Resource keys follow hierarchical naming convention
Implementation Notes: - Use RequestLocalization middleware + culture provider (cookie-based persistence) - Follow ConnectSoft.Blazor.UIKit localization patterns (Resources.resx, Resources.en.resx, Resources.he.resx) - Structure resource keys hierarchically (e.g., Navigation.Home, Common.Save) - Use ConnectSoft.Blazor.UIKit localization extensions if applicable
Tags: i18n, localization, dotnet, blazor, connectsoft
Feature 5: MKT-WEB-FEAT-005 - RTL Support (Hebrew) End-to-End¶
Description: Implement RTL rendering correctness for Hebrew across all pages and components.
Tags: rtl, hebrew, i18n, qa, blazor
Task: MKT-WEB-TASK-005¶
Title: Implement RTL rendering correctness end-to-end for Hebrew
Description: Ensure Hebrew routes render with correct RTL direction, alignment, and mirroring for navigation, lists, icons, forms, and spacing. Execute comprehensive RTL QA checklist and fix all identified issues.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - HE routes render with dir="rtl" and correct alignment/mirroring - Nav, lists, icons/chevrons, spacing behave correctly in RTL - Forms input alignment/placeholder/validation messages correct in RTL - Documented RTL QA checklist executed and issues fixed - All pages verified in RTL mode (visual QA) - RTL testing documentation created
Implementation Notes: - Consider direction-aware CSS and conditional classes; avoid fragile hacks - Use Tailwind RTL utilities and Flowbite RTL support - Test with real Hebrew content (not just direction switch) - Document RTL testing checklist for future QA
Tags: rtl, hebrew, i18n, qa, blazor
Feature 6: MKT-WEB-FEAT-006 - Marketing Pages Delivery Set A (Home + Services + How It Works)¶
Description: Deliver Home, Services, and How It Works pages with full EN/HE localization, RTL support, SEO readiness, and Figma design integration.
Tags: pages, home, services, seo, rtl, i18n
Task: MKT-WEB-TASK-006¶
Title: Deliver Home + Services + How It Works pages end-to-end (EN+HE, responsive, SEO-ready)
Description: Implement Home, Services, and How It Works pages with hero sections, key messaging, call-to-action elements, supporting EN and HE with RTL correctness, responsive design, page-level SEO metadata, optimized assets, and data-driven content structure. Integrate Figma design when design files are available.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - All three pages implemented for EN + HE with RTL correctness - Responsive verified (mobile/tablet/desktop) - Page-level metadata present (title/description/OG tags) for each page - Performance-friendly assets (optimized images, lazy loading where appropriate) - All content localized via resource files - Visual QA passed for both languages - Content is data-driven where sensible (models, JSON, or CMS-like structure) - Figma design integrated (when design files are provided by UI/UX designer)
Implementation Notes: - Use SSR-friendly components; avoid heavy client-only rendering - Optimize images (WebP format, responsive sizes) - Implement lazy loading for below-the-fold images - Use structured data (Organization, WebSite schema) where appropriate - Consider content models for services (e.g., ServiceItem model) to enable easy updates - When Figma files are available, extract design tokens, colors, typography, spacing, and implement accordingly
Tags: pages, home, services, seo, rtl, i18n, design
Task: MKT-WEB-TASK-013¶
Title: Integrate Figma design files into marketing pages
Description: When Figma design files are provided by UI/UX designer, extract design tokens (colors, typography, spacing, components), implement design system, and update all marketing pages to match the approved design. Ensure design works correctly in both EN/HE and RTL modes.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Figma design files analyzed and design tokens extracted - Design system implemented (colors, typography, spacing, component styles) - All marketing pages updated to match Figma design - Design verified in EN/HE and RTL modes - Responsive design matches Figma breakpoints - Design implementation documented
Implementation Notes: - Extract design tokens from Figma (use Figma plugins or manual extraction) - Map design tokens to Tailwind CSS custom properties or configuration - Update components and pages to match design specifications - Test design in both languages and RTL mode - Document any design system decisions or deviations
Tags: design, figma, ui, ux, pages
Feature 7: MKT-WEB-FEAT-007 - Marketing Pages Delivery Set B (About + Team)¶
Description: Deliver About and Team pages with EN/HE localization, RTL support, and data-driven team member structure.
Tags: pages, content, seo, i18n, rtl
Task: MKT-WEB-TASK-007¶
Title: Deliver About + Team pages end-to-end (EN+HE, responsive, SEO-ready)
Description: Implement About and Team pages with EN/HE localization, RTL correctness, data-driven team section for easy content updates, SEO metadata, optimized images, and proper heading hierarchy.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - About and Team pages implemented EN+HE with RTL correctness - Team section is data-driven (structured model/JSON) to support easy updates - Metadata configured per page - Responsive design verified - Team member data structure documented - Images optimized with alt text - Proper semantic HTML and heading hierarchy
Implementation Notes: - Create TeamMember model or JSON structure for team data - Use ConnectSoft.Blazor.UIKit components (Avatar, Card) for team display - Ensure images are optimized and have alt text - Follow accessibility guidelines for team page layout
Tags: pages, content, seo, i18n, rtl
Feature 8: MKT-WEB-FEAT-008 - Pricing + FAQ + Legal Pages End-to-End¶
Description: Deliver Pricing, FAQ, and Legal (Privacy Policy + Terms) pages with EN/HE localization, accessibility, and scalable content models.
Tags: pricing, faq, legal, accessibility, seo, i18n, rtl
Task: MKT-WEB-TASK-008¶
Title: Deliver Pricing + FAQ + Legal pages end-to-end (EN+HE) with accessible patterns
Description: Implement Pricing page with data-driven pricing tiers, FAQ page with accessible accordion component, and Legal pages (Privacy Policy, Terms of Service) with EN/HE localization, RTL support, accessibility compliance, canonical/hreflang handling, and structured content approach.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Pricing tiers driven from structured config/model (not hard-coded in markup) - FAQ driven from structured content; accordion accessible (keyboard + ARIA) - Privacy Policy and Terms exist in EN+HE, readable long-form layout - Canonical/hreflang handled to avoid duplication issues - All content localized - Accessibility verified (keyboard navigation, screen reader) - Responsive + RTL verified - Pricing data structure documented
Implementation Notes: - Create PricingPlan model or configuration structure - Use ConnectSoft.Blazor.UIKit Accordion component for FAQ - Ensure legal pages have proper heading hierarchy - Implement canonical URLs and hreflang tags for multilingual content - Consider markdown files or structured content for legal text - Use table or card layout with Flowbite styling for pricing
Tags: pricing, faq, legal, accessibility, seo, i18n, rtl
Feature 9: MKT-WEB-FEAT-009 - Contact Form + Submission Pipeline End-to-End¶
Description: Implement Contact page with server-side submission pipeline, form validation, and structured logging. Email/notification delivery and lead storage are stubbed for future implementation.
Tags: contact, forms, validation, logging, connectsoft
Task: MKT-WEB-TASK-009¶
Title: Implement Contact page + submission pipeline end-to-end (stub implementation)
Description: Build Contact page with form, server-side endpoint for submission, client + server-side validation, and structured logging. Email/notification delivery and lead storage are stubbed out (logged only) for future implementation. This is an end-to-end stub implementation to establish the foundation without external dependencies.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Contact page implemented EN+HE with RTL correctness - Contact form includes all required fields (name, email, message, etc.) - Server-side endpoint implemented (Minimal API endpoint or controller action) - Client-side validation implemented (HTML5 validation + JavaScript if needed) - Server-side validation implemented (data annotations or FluentValidation) - Structured logging implemented (log form submissions to Application Insights) - Email/notification delivery stubbed (logged only, no actual email sent) - Lead storage stubbed (logged only, no database persistence) - Form submission returns appropriate success/error responses - Error handling implemented for validation failures and server errors - Form works correctly in both EN and HE locales with RTL support
Implementation Notes: - Prefer server-side validation + structured logging - Use Minimal API endpoint or controller action for submission - Implement contact form model/DTO with validation attributes - Log form submissions with structured logging (Application Insights) - Stub email delivery as a service interface with no-op implementation (logged only) - Stub lead storage as a service interface with no-op implementation (logged only) - Return appropriate HTTP status codes (200 OK for success, 400 Bad Request for validation errors) - Use ConnectSoft.Blazor.UIKit form components if available - Follow ConnectSoft form validation patterns
Tags: contact, forms, validation, logging, connectsoft
Feature 10: MKT-WEB-FEAT-010 - SEO + Analytics + Observability + Launch Readiness End-to-End¶
Description: Implement complete SEO baseline, analytics integration, monitoring, and production launch readiness package.
Tags: seo, analytics, monitoring, appinsights, launch, qa, accessibility
Task: MKT-WEB-TASK-010¶
Title: Implement SEO baseline + analytics + monitoring + production launch package end-to-end
Description: Configure per-page metadata templates, generate sitemap.xml and robots.txt, implement canonical URLs and hreflang tags, add structured data, integrate analytics (GA4 or approved alternative), configure Application Insights/OpenTelemetry, set up error monitoring, execute final QA checklist, document runbook, and establish performance baseline.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Per-page metadata templates (title/description/OG/Twitter cards) - sitemap.xml generated and correct for both languages - robots.txt configured and correct - Canonical URLs + hreflang configured for EN/HE - Structured data added where appropriate (Organization/WebSite schema) - Analytics integrated (GA4 or approved alternative) with key events (language switch, contact submit) - Application Insights / OpenTelemetry configured for server logs, requests, failures - Error monitoring strategy in place (App Insights exceptions at minimum) - Final QA checklist executed (EN/HE, RTL/LTR, mobile, accessibility basics) - Runbook documented: deploy, rollback, config/secrets, content update steps - Performance baseline established (Core Web Vitals tracked) - All pages have unique, descriptive metadata
Implementation Notes: - Use dynamic metadata generation (component-based or middleware) - Generate sitemap.xml programmatically or via build process - Implement hreflang tags for language variants - Use JSON-LD for structured data - Configure Application Insights SDK in Program.cs - Set up custom events for key user actions - Create alerts for error rates and performance degradation - Document operational procedures in runbook - Execute comprehensive QA checklist before launch
Tags: seo, analytics, monitoring, appinsights, launch, qa, accessibility, i18n, rtl
Task: MKT-WEB-TASK-016¶
Title: Implement cookie consent banner end-to-end (GDPR compliance)
Description: Implement cookie consent banner for GDPR and privacy compliance when using analytics (GA4) or other tracking technologies. Create localized banner component (EN/HE) with RTL support, cookie preference management, and integration with analytics initialization. Ensure banner appears on first visit and allows users to manage cookie preferences.
Repository: ConnectSoft.MarketingSite
Acceptance Criteria: - Cookie consent banner implemented with EN/HE localization and RTL support - Banner appears on first visit (cookie-based preference storage) - Users can accept all, reject non-essential, or customize cookie preferences - Cookie preferences are stored and respected across page navigation - Analytics (GA4) only initializes after user consent (if required by compliance) - Banner is accessible (keyboard navigation, screen reader support) - Cookie preference management page/component available (if required) - Banner styling is consistent with site design (Tailwind/Flowbite) - Compliance requirements documented (GDPR, CCPA considerations)
Implementation Notes: - Use cookie-based preference storage for consent state - Integrate with analytics initialization (conditional loading based on consent) - Consider using ConnectSoft.Blazor.UIKit Banner component if applicable - Ensure banner does not interfere with site functionality - Document compliance approach (which cookies are essential vs. non-essential) - Test consent flow and preference persistence - Consider privacy policy link in banner
Tags: cookie-consent, gdpr, privacy, analytics, compliance, i18n, rtl
Feature 11: MKT-WEB-FEAT-011 - Shell Template Improvements¶
Description: Identify, document, and fix issues found in ConnectSoft.Blazor.ShellTemplate during marketing site development, and contribute improvements back to the template.
Tags: template, shell-template, improvements, foundation
Task: MKT-WEB-TASK-011¶
Title: Improve and organize ConnectSoft.Blazor.ShellTemplate based on findings
Description: During marketing site development, identify issues, gaps, or improvements needed in ConnectSoft.Blazor.ShellTemplate. Document findings, implement fixes or enhancements, and contribute improvements back to the template repository. Ensure template improvements are backward compatible and follow ConnectSoft engineering standards.
Repository: ConnectSoft.MarketingSite (for tracking), ConnectSoft.Blazor.ShellTemplate (for contributions)
Acceptance Criteria: - Issues/gaps in ShellTemplate documented with examples - Fixes or enhancements implemented and tested - Improvements contributed back to ConnectSoft.Blazor.ShellTemplate repository - Changes are backward compatible (if applicable) - Documentation updated for template improvements - Pull request created for template repository (if applicable)
Implementation Notes: - Track issues found during development in work item discussion or documentation - Prioritize improvements that benefit multiple projects - Follow ConnectSoft contribution guidelines for template repositories - Test improvements in context of marketing site before contributing - Document breaking changes clearly if any
Tags: template, shell-template, improvements, foundation
Feature 12: MKT-WEB-FEAT-012 - UIKit Improvements¶
Description: Identify missing components or features in ConnectSoft.Blazor.UIKit needed for marketing site, and contribute improvements back to the UIKit library.
Tags: uikit, improvements, components, foundation
Task: MKT-WEB-TASK-012¶
Title: Improve ConnectSoft.Blazor.UIKit based on marketing site requirements
Description: During marketing site development, identify missing components, features, or improvements needed in ConnectSoft.Blazor.UIKit. Document requirements, implement missing components or enhancements, and contribute improvements back to the UIKit repository. Ensure UIKit improvements follow library standards and include tests.
Repository: ConnectSoft.MarketingSite (for tracking), ConnectSoft.Blazor.UIKit (for contributions)
Acceptance Criteria: - Missing components/features in UIKit documented with use cases - Missing components or enhancements implemented with tests - Improvements contributed back to ConnectSoft.Blazor.UIKit repository - Changes follow UIKit architecture and patterns - Unit tests included for new components/features - Documentation updated for UIKit improvements - Pull request created for UIKit repository (if applicable)
Implementation Notes: - Track missing components/features during development - Prioritize improvements that benefit multiple projects using UIKit - Follow ConnectSoft.Blazor.UIKit contribution guidelines - Include unit tests and accessibility tests for new components - Update UIKit documentation and examples - Ensure Flowbite adapter support for new components
Tags: uikit, improvements, components, foundation
Epic: MKT-TPL-EPIC-001¶
Title: Create Reusable Marketing Site Template — .NET Template Engine — ConnectSoft.MarketingSiteTemplate
Description:
Create a reusable .NET template from the completed marketing site that can be used with the dotnet new template engine to scaffold new marketing sites. The template will package all the production-ready marketing site code, configuration, and infrastructure as a reusable template with customizable parameters.
Definition of Done:
- Template repository created with proper structure (.template.config/template.json)
- Template parameters defined for customization (company name, project name, etc.)
- Template packaged as NuGet package and installable via dotnet new install
- Template documentation complete (README, getting started guide, parameter reference)
- CI/CD pipeline configured for template packaging and publishing
- Template tested and validated by generating sample projects
- Template follows ConnectSoft template patterns and standards
Tags: connectsoft, template, marketing-site, blazor, dotnet-template, reuse
Feature 13: MKT-TPL-FEAT-001 - Template Structure and Configuration¶
Description: Create template repository structure, configure .template.config/template.json, set up template metadata, and organize template files for distribution via .NET template engine.
Tags: template, structure, configuration, foundation
Task: MKT-TPL-TASK-001¶
Title: Create template repository structure and configuration end-to-end
Description:
Create ConnectSoft.MarketingSiteTemplate repository, configure .template.config/template.json with template metadata (identity, short name, author, classifications), set up template file structure, define template sources and exclusions, and organize files for template packaging. Extract marketing site code into template-ready structure.
Repository: ConnectSoft.MarketingSiteTemplate
Acceptance Criteria:
- Template repository created with proper folder structure
- .template.config/template.json configured with template identity, short name, author
- Template metadata includes classifications (Web, Blazor, Marketing Site, Template)
- Template sources configured to include all necessary files
- Template exclusions configured (.git, .vs, bin, obj, TestResults, etc.)
- Marketing site code extracted and organized in template structure
- Template follows ConnectSoft template patterns (similar to other templates)
- Template structure validated and tested locally
Implementation Notes:
- Follow ConnectSoft template structure patterns (similar to ConnectSoft.Blazor.MicrofrontendLibraryTemplate)
- Place .template.config/ at repository root
- Configure template identity: ConnectSoft.MarketingSite.Template
- Configure short name: connectsoft-marketing-site (canonical; see template-naming-guide)
- Include all marketing site files except build artifacts
- Reference ConnectSoft.Documentation template patterns
- Use conditional file inclusion if needed for optional features
Tags: template, structure, configuration, foundation
Feature 14: MKT-TPL-FEAT-002 - Template Parameters and Customization¶
Description: Define template parameters for customization (company name, project name, framework version, optional features) and implement parameter replacement logic throughout template files.
Tags: template, parameters, customization, configuration
Task: MKT-TPL-TASK-002¶
Title: Implement template parameters and customization logic end-to-end
Description: Define template parameters (CompanyName, ProjectName, Framework version, optional features), implement parameter replacement using template symbols, configure conditional file inclusion based on parameters, test parameter substitution, and validate generated projects with different parameter combinations.
Repository: ConnectSoft.MarketingSiteTemplate
Acceptance Criteria:
- Template parameters defined in template.json (CompanyName, ProjectName, Framework, etc.)
- Parameter symbols configured with types, defaults, and descriptions
- Parameter replacement working correctly in all template files
- Namespace and project name replacements functional
- Conditional file inclusion based on parameters (if applicable)
- Parameter validation and constraints configured
- Template generates valid projects with different parameter values
- Generated projects build and run correctly
Implementation Notes:
- Define core parameters: CompanyName (default: ConnectSoft), ProjectName (default: MarketingSite), Framework (net9.0)
- Consider optional parameters: EnableAnalytics, EnableCookieConsent, DefaultLanguage
- Use template symbol syntax: ${{CompanyName}}, ${{ProjectName}}
- Test with various parameter combinations
- Ensure namespace replacements work correctly
- Reference other ConnectSoft template parameter patterns
Tags: template, parameters, customization, configuration
Feature 15: MKT-TPL-FEAT-003 - Template Packaging and Distribution¶
Description: Create NuGet package specification (.nuspec), configure packaging pipeline, set up template distribution via NuGet feed, and validate template installation process.
Tags: template, packaging, nuget, distribution
Task: MKT-TPL-TASK-003¶
Title: Package template as NuGet and configure distribution end-to-end
Description:
Create .nuspec file for template packaging, configure NuGet package metadata (ID, version, description, authors, tags), set up file inclusion/exclusion rules, test NuGet package creation, validate template installation via dotnet new install, and configure package publishing workflow.
Repository: ConnectSoft.MarketingSiteTemplate
Acceptance Criteria:
- .nuspec file created with proper metadata
- NuGet package ID follows ConnectSoft naming: ConnectSoft.MarketingSiteTemplate
- Package versioning strategy defined
- File inclusion/exclusion rules configured correctly
- NuGet package builds successfully
- Template installable via dotnet new install <package-id>
- Template appears in dotnet new list output
- Package publishing workflow configured (Azure Artifacts or NuGet.org)
Implementation Notes:
- Follow ConnectSoft template packaging patterns
- Package ID: ConnectSoft.MarketingSiteTemplate or similar
- Include .template.config/, source files, documentation
- Exclude build artifacts, test results, .git folders
- Test local installation: dotnet new install ./path/to/template
- Test NuGet installation: dotnet new install ConnectSoft.MarketingSiteTemplate
- Configure Azure Artifacts feed or NuGet.org publishing
- Reference ConnectSoft.Blazor.MicrofrontendLibraryTemplate.nuspec as example
Tags: template, packaging, nuget, distribution
Feature 16: MKT-TPL-FEAT-004 - Template Documentation¶
Description: Create comprehensive template documentation including README, getting started guide, parameter reference, usage examples, and troubleshooting guide.
Tags: template, documentation, getting-started, reference
Task: MKT-TPL-TASK-004¶
Title: Create template documentation end-to-end
Description: Write template README with overview and quick start, create getting started guide with step-by-step instructions, document all template parameters with descriptions and examples, provide usage examples for common scenarios, create troubleshooting guide, and ensure documentation follows ConnectSoft documentation standards.
Repository: ConnectSoft.MarketingSiteTemplate
Acceptance Criteria: - README.md created with template overview, installation, and quick start - Getting started guide created with detailed step-by-step instructions - Parameter reference documentation complete (all parameters documented) - Usage examples provided (basic usage, advanced scenarios) - Troubleshooting guide included (common issues and solutions) - Documentation follows ConnectSoft documentation standards and style - Documentation includes code examples and screenshots where appropriate - Template usage documented with real-world scenarios
Implementation Notes:
- Follow ConnectSoft documentation patterns from other templates
- Include installation instructions (NuGet install)
- Document all template parameters with examples
- Provide usage examples: dotnet new connectsoft-marketing-site -n MySite --CompanyName MyCompany
- Include troubleshooting section for common issues
- Reference ConnectSoft.Blazor.UIKit template documentation as example
- Consider adding template icon/logo if applicable
Tags: template, documentation, getting-started, reference
Feature 17: MKT-TPL-FEAT-005 - CI/CD for Template¶
Description: Configure Azure DevOps pipeline for template packaging, versioning, testing, and publishing to NuGet feed.
Tags: template, cicd, pipeline, packaging, devops
Task: MKT-TPL-TASK-005¶
Title: Configure CI/CD pipeline for template packaging and publishing end-to-end
Description: Create Azure DevOps pipeline for template build, test template generation in pipeline, configure NuGet package creation, set up versioning strategy, configure package publishing to Azure Artifacts, add pipeline validation steps, and document pipeline configuration.
Repository: ConnectSoft.MarketingSiteTemplate
Acceptance Criteria:
- Azure DevOps pipeline created (azure-pipelines.yml or similar)
- Pipeline builds template and validates structure
- Pipeline tests template generation (generate sample project and verify it builds)
- NuGet package creation automated in pipeline
- Versioning strategy configured (semantic versioning or similar)
- Package publishing to Azure Artifacts configured
- Pipeline validation steps included (template validation, generated project build)
- Pipeline follows ConnectSoft pipeline patterns
- Pipeline documentation included
Implementation Notes:
- Use Azure DevOps pipeline templates from ConnectSoft standards
- Include template validation step
- Test template by generating sample project: dotnet new install . --force
- Verify generated project builds: dotnet build
- Configure semantic versioning (major.minor.patch)
- Publish to Azure Artifacts feed (ConnectSoft template feed)
- Reference other template pipeline configurations
- Include quality gates (build, test, validate)
Tags: template, cicd, pipeline, packaging, devops
Work Item Summary¶
| Type | Count | IDs |
|---|---|---|
| Epic | 2 | MKT-WEB-EPIC-001, MKT-TPL-EPIC-001 |
| Features | 17 | MKT-WEB-FEAT-001 through MKT-WEB-FEAT-012, MKT-TPL-FEAT-001 through MKT-TPL-FEAT-005 |
| Tasks | 29 | MKT-WEB-TASK-001 through MKT-WEB-TASK-024, MKT-TPL-TASK-001 through MKT-TPL-TASK-005 |
Work Item Metadata¶
Marketing Site Development (MKT-WEB-EPIC-001)¶
- Assignment: All work items assigned to anton.ukrainets@gmail.com
- Area Path: ConnectSoft\Offshore-ConnectSoft-Team
- Iteration: ConnectSoft\Sprint 2026-02
- Repository: ConnectSoft.MarketingSite
- Parent-Child Structure: Epic -> Features (as children of Epic) -> Tasks (as children of Features)
Marketing Site Template (MKT-TPL-EPIC-001)¶
- Assignment: All work items assigned to anton.ukrainets@gmail.com
- Area Path: ConnectSoft\Offshore-ConnectSoft-Team
- Iteration: ConnectSoft\Sprint 2026-03
- Repository: ConnectSoft.MarketingSiteTemplate
- Parent-Child Structure: Epic -> Features (as children of Epic) -> Tasks (as children of Features)
Notes¶
Marketing Site Development (MKT-WEB-EPIC-001)¶
- All work items use the MKT-WEB prefix (MKT-WEB-EPIC-001, MKT-WEB-FEAT-###, MKT-WEB-TASK-###)
- Tasks are designed as end-to-end deliverables (large, complete slices of functionality)
- Infrastructure uses Pulumi (C#) following ConnectSoft patterns
- .NET 9 is used throughout the project
- Figma design integration is handled as a separate task (MKT-WEB-TASK-013) when design files are available
- Shell Template and UIKit improvements are tracked as separate features to contribute back to template/library repositories
- Iteration: ConnectSoft\Sprint 2026-02
- Repository: ConnectSoft.MarketingSite
Marketing Site Template (MKT-TPL-EPIC-001)¶
- All work items use the MKT-TPL prefix (MKT-TPL-EPIC-001, MKT-TPL-FEAT-###, MKT-TPL-TASK-###)
- Template work begins after marketing site is complete
- Template will be created from the completed marketing site codebase
- Template follows ConnectSoft template patterns and standards
- Template will be packaged as NuGet and distributed via .NET template engine
- Iteration: ConnectSoft\Sprint 2026-03
- Repository: ConnectSoft.MarketingSiteTemplate
General Notes¶
- Work items will be created using Azure DevOps MCP server tools
- All work items assigned to anton.ukrainets@gmail.com
- Area Path: ConnectSoft\Offshore-ConnectSoft-Team