Deliver an audit experience in the frontend that lets users inspect an object’s lifecycle in context across the authoring workspace, showing who performed each action, when it happened, and the relevant version or language variant. The UI should surface immutable activity records for creation, edits, status changes, checkout/check-in, deletion, and restore through the appropriate panel or object detail views, with clear loading, empty, and error states backed by shared hooks and store patterns. The feature should integrate with the platform API and real-time updates so audit history stays current without disrupting the user’s workflow, while respecting workspace permissions and existing navigation patterns. This gives users compliance-grade traceability directly in the interface, making investigations faster and accountability easier to understand.
Deliver a frontend experience in Authoring that makes the full version hierarchy understandable and actionable, so users can browse, compare, and manage versions, subversions, language variants, and formats without losing context. The UI should surface this model through the object list, hierarchy views, version and language selectors, metadata panels, and lifecycle dialogs, with state kept in sync with platform APIs and real-time updates where available. The epic should cover clear loading, validation, and error states using shared hooks, stores, and error-handling patterns, while preserving traceability and audit-ready history in user-facing flows such as create version, create subversion, check-in, and delivery-related updates. The result should reduce release risk and support parallel work by giving teams a reliable, intuitive way to see exactly what exists, what changed, and what is ready across all content variants.
Deliver the Table Content Transformer frontend experience within the AI Tools area so users can navigate its Projects, Files, and Terms views, open detail pages, and work with transformation data through clear, responsive React panels and page states. The epic should cover how the UI fetches and presents transformer data from the platform API, manages loading, empty, error, and permission-gated states, and keeps navigation aligned with workspace and route context. Frontend implementation should use shared hooks and store patterns where appropriate to coordinate list/detail state, user actions, and refresh behavior, with consistent feedback through dialogs, toasts, and error boundaries. The result should make the transformer feel like a first-class Aleido workflow in both web and desktop clients without expanding beyond the existing AI Tools scope.
Notifications-FE delivers the user-facing notification experience across web and desktop, surfacing timely alerts for content, workflow, and collaboration activity in toasts and a reviewable notification history without requiring users to manually check for changes. The frontend should integrate platform APIs and real-time updates to keep notification state current, while using shared hooks and stores to manage unread counts, history loading, and workspace-aware visibility consistently across the app shell. The experience should fit Aleido’s existing overlay and panel patterns, support clear navigation from a notification to the relevant area of the product, and handle loading, empty, and failure states through the platform’s unified error-handling approach. This improves team awareness and reduces delays by making important activity visible immediately and persistently.
Deliver a unified, read-only preview experience inside the Authoring workspace so authors can inspect the currently selected object in context without leaving the existing panel layout. The frontend should render a consistent preview surface for supported content types, resolve and display referenced content and conditional output as returned by the platform API, and expose profiling filters and visualization controls that let users simulate targeted delivery states. State should stay in sync with object selection, version and language changes, and workspace context, with clear loading, empty, and error handling in the preview panel and lightweight telemetry emitted for key preview interactions. This gives authors faster review cycles and more confidence in content quality while keeping the experience focused on validation rather than editing or branded presentation.
Administrator Tools on the frontend should give authorized users a clear, centralized administration experience for configuring the platform, managing permissions, workflows, and user roles without developer intervention. The UI should surface these capabilities through permission-aware navigation, forms, panels, dialogs, and feedback states that integrate cleanly with the platform API and reflect the active workspace or tenant context where applicable. Frontend implementation should use shared hooks and store patterns to keep admin data, loading, and mutation state consistent, while applying unified error handling, access-denied states, and responsive success feedback for secure and reliable administration workflows. This delivers a scalable, user-facing control surface that helps organizations maintain governance, compliance, and operational efficiency as their needs evolve.
Deliver an advanced search experience in the frontend that lets users move seamlessly from fast free-text suggestions to a full search workflow, with clear results, direct object actions, and precision filtering across all object properties. In the Authoring workspace, search should integrate naturally with the existing panel and perspective patterns, keeping query state, selected filters, and result context consistent as users navigate, refine, and act on items. The UI should use shared hooks and store patterns to manage search state and platform API integration, while handling loading, empty, and failure states through the platform’s unified error-handling approach. The outcome is a faster, lower-friction discovery flow that reduces clicks for common actions and still supports deeper investigative search when users need it.
Recipe Management on the frontend will provide a dedicated Recipes workspace where users can create, view, and maintain hierarchical publication structures, define rule-based matching criteria, and see matched platform objects organized into ordered navigation trees. The experience should use Aleido’s panel and perspective patterns to support guided authoring, progress visibility, and clear transitions between recipe structure editing, rule configuration, and result review, with state kept in sync with platform APIs and real-time updates where available. The UI should make coverage, readiness, and metadata-driven inclusion understandable at a glance, while handling loading, empty, error, and permission states consistently through shared hooks, stores, and error handling patterns. This enables faster publication assembly, reduces manual curation, and gives authors a clearer, more reliable way to prepare multi-variant deliverables and externally mapped content.
Deliver the Reuse Analyser as a user-facing AI tool that helps information analysts explore and understand reuse potential across repository content through a clear, responsive interface in the Aleido Platform. The frontend should present analysis results in the established workspace and panel patterns, support loading, empty, and error states consistently, and integrate with the platform API through shared hooks and store-managed state so users can refine context and review findings without losing navigation state. The experience should make repository-wide analysis understandable and actionable with accessible result presentation, progressive feedback while AI processing runs, and resilient error handling for failed or partial responses.
Release Manager on the frontend gives users a dedicated workspace to review incoming content, understand how it aligns to recipe-based product structures, and control what is released to which external targets. The experience should make release scope, target channels and markets, and release status visible through clear panels, lists, and detail views, with state managed consistently across navigation, filtering, selection, and API-backed actions. Frontend implementation should integrate tightly with platform release APIs to support responsive feedback, optimistic updates where safe, and robust error handling for failed validations or delivery actions. This enables users to move from publication-focused delivery to product-focused delivery with greater confidence, traceability, and less manual effort.
This epic delivers the frontend experience for content lifecycle workflows in the Authoring workspace, so users can clearly see each content item’s current stage, ownership, and pending actions as they move through review, approval, and publication. The UI should surface lifecycle status within the existing authoring panels and object interactions, with responsive filtering, visual state cues, and contextual actions that are driven by platform API data and kept in sync through shared hooks and store state. The experience should help users quickly identify blockers and bottlenecks, handle loading and failure states through the platform’s unified error patterns, and support fast, reliable updates without losing workspace context. Overall, the frontend should make workflow progress transparent and actionable, improving team throughput and confidence in the publication process.
This epic brings Work Package Context into the frontend as a persistent, version-aware experience that lets users see, understand, and maintain the shared context a work package depends on throughout its lifecycle. In the UI, that means exposing context in the relevant workspace views and panels with clear loading, empty, error, and version states, so both human users and AI-assisted workflows can reliably work from the same current and traceable information. The frontend should manage this through shared hooks and store-backed state integrated with the platform API, including refresh and real-time update handling where available, while keeping edits and saves understandable and resilient through consistent feedback and error handling. The result should make context feel visible, trustworthy, and continuously up to date without breaking existing authoring and delivery flows.