==================================================
 STORYGEN AI — STORY EXPORT
==================================================
Story ID:           25
Title:              ClaaS Developer Version 2 (Conventional)
Owner:              Noel Anthony - Product Manager <noel.anthony@educlaas.com>
App Type:           Conventional App
Input Type:         file
Status:             features_generated
Source File:        End_to_End_Process_Feature_lists_CLaaS_Developer.pdf
Created:            2026-04-29 07:50:56 UTC
Updated:            2026-04-29 07:53:41 UTC
Features Generated: 2026-04-29 07:53:41 UTC
Total Clusters:     9
Total Features:     18

--- ORIGINAL INPUT ---
End-to-End Process Feature Lists – CLaaS Developer 
Converted from Excel workbook: End_to_End_Process_Feature_lists_CLaaS Developer.xlsx | Sheet: Developer 
 
Module Feature Cluster 	Feature 	Description 	Workflow 
CLaaS Developer Product Catalogue 	Master list of the modules-- Session Plan 
details 
Session Plan Details 	1. View list of Modules & Sessions 
2. Session Plan review (internal & External) 
3. Internal view per module (with links per IU) 
4. External view (with links) 
CLaaS Developer ClaaS Master Course Information 
(Product Catalogue) 
Master list of the modules-- --Product code & 
name-- Course Code & Name -- Product Plan 
Course Details (Fetched via API from the Product 
Apps) 
1. Product Name 
2. Product Code 
3. Course Code 
4. Course Name 
5. Product Plan 
6. Module Details 
CLaaS Developer ClaaS Seestion Plan copy Copy Sessin plan, KSA, IU's -> new module Copy an existing session plan with all contents 
(Links, generated files, Autograder Scrip, etc) to a 
new product  
1. Select session plan module to copy 
2. Select the module to copy over 
3. Select confirm 
 
CLaaS Developer CLaaS Product Admin Course & Product Creation – Product Product record (manual create course & product 
capability) 
- Funtion is an option if product not available in 
the products apps(fetched via API) 
1. Create a record for each module 
2. Connect the module to its parent course 
3. Set the module code, title, and how long it takes to 
complete 
4. Add the LMS course code and the link to the LMS course 
page 
5. Connect the module to its Technical Skills and 
Competency (TSC) entry 
6. Turn on sync if needed and set the order in which modules 
appear 
CLaaS Developer CLaaS Course Admin Course & Product Creation – Courses Course record 	1. Create a record for each course 
2. Set both the internal and public-facing course names 
3. Add the course code and specify the course type 
4. Turn on the sync setting if the course needs to stay 
updated automatically 
5. Set the order in which courses appear 
CLaaS Developer CLaaS Product Admin Course & Product Document Automation – 
Course-Product Mapping 
Course-module mapping 	1. Link each module to its parent course 
2. Set the course and module references for each mapping 
3. Assign a unique identifier to each course-module link 
CLaaS Developer CLaaS Proficiency Admin Product Planning & Structure – Proficiency 
Goals 
Proficiency goal config 	1. Add the proficiency goals (e.g Basic & Advance) 
2. Give each goal a name and short reference name 
3. Set the order in which they appear 
CLaaS Developer CLaaS KSA Admin 	KSA & Proficiency Mapping – Proficiency 
Groupings 
Proficiency grouping 	1. Create proficiency grouping entries 
2. Connect each grouping to its competency level 
3. Connect each grouping to its proficiency goal 
4. Assign the matching learning management system (LMS) 
group 
5. Set the order in which they appear 
CLaaS Developer CLaaS Instructional Unit Admin Instructional Unit (IU) Management – Session 
Modes 
Session mode config 	1. Add the session delivery modes (e.g. Synchronous, 
Asynchronous) 
2. Add the sub-types under each session mode 
3. Give each mode and sub-type a name and set the order in 
which they appear 
CLaaS Developer CLaaS Instructional Unit Admin Instructional Unit (IU) Management – Asset 
Format Types 
Asset format type config 	1. Add the asset format types (e.g, PDF) 
2. Give each format a name and short reference name 
3. Set the order in which they appear

Module Feature Cluster 	Feature 	Description 	Workflow 
CLaaS Developer CLaaS Grading Criteria Admin Product Planning & Structure – Competency 
Levels--Confiquration of generated from 
rubrics to Actionable prompt for Autograder  
Competency level config 	1. Add the competency levels (e.g. Basic =>Fail(49% & 
below),Foundation(50-74%), Proficient(75% & Above) & 
Advance =>Fail(49% & below),Foundation(50-59%), 
Proficient(60% & 79%), Expert(80% & above)) 
2. Give each level a short reference name 
3. Set the order in which they appear 
4. Assign a unique identifier to each level 
CLaaS Developer CLaaS Content Grouping Admin Product Planning & Structure – Content 
Grouping--Prompt 
Content group config 	1. Add the content categories and problem types 
2. Give each category a name and short reference name 
3. Set the order in which they appear 
4. Assign a unique identifier to each category 
CLaaS Developer CLaaS Content Type Admin AI Content & Assessment Generation – 
Session Mode Content Types-- Prompts 
Content type config 	1. Add the content types available for each session mode 
2. Add the prompts used to generate content with AI 
3. Add the prompts used to evaluate and score the content 
4. Add the prompt used to configure automatic grading 
5. Connect each content type to its format type and content 
category 
6. Indicate whether this content type can be AI-generated 
CLaaS Developer CLaaS Assessment type Admin Assessment Automation – Assessment 
Types-- Prompts 
Assessment type config 	1. Add the assessment types 
2. Connect each assessment type to its content category 
3. Link each assessment to its problem type 
4. Associate each assessment with its session mode and 
session mode sub-type 
5. Set the order in which they appear 
CLaaS Developer CLaaS TSC Admin 	Product Planning & Structure – Technical 
Skills & Competencies (TSC) 
TSC config 	1. Add the Technical Skills and Competency (TSC) codes and 
titles 
2. Set the TSC categories and descriptions 
3. Fill in the related knowledge and skills details 
4. Set the order in which they appear 
5. Assign a unique identifier to each TSC entry 
CLaaS Developer CLaaS Product Admin Foundation Setup – Languages & 
Technologies 
Reference data config 	1. Add the languages that the platform will support 
2. Add the technologies that will be used 
3. Give each entry a name and set the order in which they 
appear 
CLaaS Developer CLaaS Product Admin User Administration – User Setup--RBA User record 	1. Create a record for each user 
2. Enter the user's name and email address 
3. A unique user ID is generated automatically 
4. Connect the user to the relevant modules and assign their 
role 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module 
Knowledge 
Module knowledge 	1. Add the knowledge items that belong to each module 
2. Give each knowledge item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which knowledge items appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module Skills Module skill 	1. Add the skill items that belong to each module 
2. Give each skill item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which skill items appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module Abilities Module ability 	1. Add the ability items that belong to each module 
2. Give each ability item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which ability items appear 
5. Assign a unique identifier to each ability item 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Create 
IUs 
Instructional unit 	1. Create an Instructional Unit (IU) record for each module 
2. Give the IU a name and set the order in which it appears 
3. Connect it to its parent module 
4. Assign a unique IU identifier 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Knowledge 
Items 
IU knowledge mapping 	1. Assign the relevant knowledge items to each Instructional 
Unit (IU) 
2. Connect each knowledge item to its source in the module

Module Feature Cluster 	Feature 	Description 	Workflow 
knowledge list 
3. Connect it to its Instructional Unit 
4. Set the order in which knowledge items appear within the 
IU 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Skill Items IU skill mapping 	1. Assign the relevant skill items to each Instructional Unit 
(IU) 
2. Connect each skill item to its source in the module skills 
list 
3. Connect it to its Instructional Unit 
4. Set the order in which skill items appear within the IU 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Ability Items IU ability mapping 	1. Assign the relevant ability items to each Instructional Unit 
(IU) 
2. Connect each ability item to its source in the module 
abilities list 
3. Connect it to its Instructional Unit 
4. Set the order in which ability items appear within the IU 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Session 
Plans 
Session plan 	1. Create a session plan record for each Instructional Unit 
(IU) 
2. Connect the session plan to its Instructional Unit 
3. Set the session delivery mode, sub-type, and content type 
4. Set the session duration (in minutes) and its reference 
number 
5. Add the link to the content repository 
6. Set the order in which session plans appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Session Plan to 
PC Groupings 
Session-PC grouping mapping 	1. Connect each session plan to its proficiency and 
competency grouping 
2. Link the session plan to the session plans list 
3. Link it to the proficiency and competency groupings list 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Content 
Mapping 
Content mapping 	1. Link each content item to its Instructional Unit and module 
2. Connect it to its proficiency and competency grouping 
3. Set the session delivery mode, sub-type, content type, and 
file format 
4. Assign the relevant technologies 
5. Set the order in which it appears within the IU and within 
the module 
CLaaS Developer ClaaS Session Plan Entry Session Plan Entry 	Session Plan Confiq 	1. Session Plan groups 
2. Instructional Unit 
3. Session Mode 
4. Category 
5. Content Type 
6. Topic 
7. Session Day and Week 
8. Duration of content 
CLaaS Developer CLaaS Product Development AI Content & Assessment Generation – 
Content Repository 
Content repository & Content generation 1. Create a content record for each Instructional Unit and 
module 
2. Connect it to its Instructional Unit and module 
3. Set the session delivery mode, sub-type, and content type 
4. Add the SharePoint file details (file ID, link, name, and tags) 
5. Enter the prompt used to generate this content with AI 
6. Set how the file was created and the order in which it 
appears 
CLaaS Developer CLaaS Product Development Assessment Automation – Content Rubrics Content rubric generation 	1. Create a rubric record and link it to the relevant content 
item 
2. Connect it to its Instructional Unit, module, and course 
3. Add the prompt used to evaluate and score this content 
4. Add the SharePoint file details for the rubric (file ID, link, 
name, and tags) 
5. Connect it to its session delivery mode and sub-type 
CLaaS Developer CLaaS Product Development Assessment Automation – Autograding Autograding config & generation 	1. Create an autograding setup record for each content item

Module Feature Cluster 	Feature 	Description 	Workflow 
Configuration 	2. Link it to the relevant content item and its rubric 
3. Connect it to the module, course, and session records 
4. Add the grading script 
5. Add the SharePoint file details for the grading file 
6. Connect it to its Instructional Unit 
CLaaS Developer AutoGrader Engine 	grading--configurations–assignments grade_conf_id 
order_index 
session_id 
session_plan_id 
course_code 
course_name 
module_name 
instructional_unit 
session_mode 
category 
content_topic 
prompt_file_name 
prompt_file_mime 
prompt_file_size 
prompt_file_data 
created_at 
updated_at 
1. Set a unique ID for each grading configuration 
2. A sequence number is assigned automatically 
3. Add the external session reference ID 
4. Link the configuration to a specific session plan 
5. Enter the course code (e.g. PCDI1) 
6. Enter the full course title 
7. Enter the module name 
8. Enter the specific lesson unit 
CLaaS Developer Autograder Submission grading–submissions–score–email grade_sub_id 
grade_conf_id 
learner_email 
cohort_code 
learner_file_data 
prompt_file_data 
openai_response 
is_openai_response_valid 
is_email_sent 
is_grading_completed 
process_attempt_count 
process_attempt_logs 
created_at 
1. Set a unique ID for each submission 
2. Link the submission to its grading configuration 
3. Enter the learner's email address 
4. Enter the cohort code that the learner belongs to 
5. Attach the learner's submitted file 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Total Users 	Count of total registered users 	1. Pull the list of all registered users 
2. Count the total number of users 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Active Sessions Count of active module session plans 1. Pull the list of all module session plans 
2. Count the total number of active sessions 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Modules Created Count of product app modules created 1. Pull the list of all product modules 
2. Count the total number of modules created 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Chart – Content Volume Content repository volume by creation method 
and date 
1. Pull the content repository records 
2. Group content by the date it was created 
3. Break down each group by how the content was made (e.g. 
uploaded, AI-generated) 
4. Show the results as a chart on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Chart – User Distribution User role distribution: Admin, User, Technology 1. Pull the list of all users 
2. Categorise each user as Admin, User, or Technology based 
on their name/role 
3. Show the breakdown as a distribution chart on the 
dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Table – Recent Activity Recent activity across modules, sessions, and 
content (5 rows) 
1. Count the total number of modules created 
2. Count the total number of active sessions 
3. Count content items that were manually uploaded via link 
4. Count content items that were AI-generated 
5. Count content items uploaded via SharePoint link

Module Feature Cluster 	Feature 	Description 	Workflow 
6. Display all five counts as a recent activity summary table 
on the dashboard 
CLaaS Developer Product Analytics / PowerBI Learner Feedback - fetched from ClaaS 
Manager 
A report focusing on learners Feedback on 
product. 
Load embedded Power BI report → fetch learner analytics 
(Learner feedback.) → render interactive dashboard inside 
iframe → allow users to view and analyze learner feedback 
metrics 
CLaaS Developer Curricumlum Framework 
Alignment 
Curriculum Framework Alignment & Gap 
Analysis 
Framework Confiquration 	1.Confiqure the country 
2. Load the Product Plan 
3. Load the skillsframework 
4. Perform Alignment Check 
5. Higliglight alignment & Gap 
6. Recommendations to fill the idenfied gaps 
     
     
Under Development 
Future Enhancements 
Integration with LMS 
 
Note: Multi-line Excel cell content has been preserved as line breaks in the Word table.

--- USER STORY ---
# CLaaS Developer Platform – End-to-End Course Product Development & Management

## Overview
This is a **Conventional App**. The CLaaS Developer platform is a comprehensive course-product authoring and management system that enables curriculum developers and administrators to build, configure, and maintain modular learning products — from master course catalogues and session plans down to instructional units, KSA mappings, AI-generated content, rubrics, and autograder configurations. The application provides structured forms, CRUD-based admin screens, dashboards, and explicit user-driven workflows to standardize how learning products are created, reused, assessed, and analyzed.

## Actors
- **Product Developer / Curriculum Designer**: Creates and maintains modules, instructional units (IUs), session plans, KSA mappings, content items, rubrics, and autograder configurations.
- **CLaaS Administrator**: Manages reference/master data — courses, products, proficiency goals, competency levels, session modes, asset format types, content groupings, content types, assessment types, TSCs, languages, and technologies.
- **User Administrator**: Creates user records, assigns roles, and manages module-level role-based access.
- **Curriculum Framework Reviewer**: Performs alignment checks between product plans and national/external skills frameworks.
- **Learner (indirect)**: Submits assignments to the autograder; their submissions and feedback are consumed by the platform.
- **Analytics Consumer (Product Owner / Manager)**: Views Power BI dashboards covering KPIs, content volume, user distribution, recent activity, and learner feedback.

## Goals
- Provide a single source of truth for course-product structure (Course → Module → IU → Session Plan → Content).
- Standardize KSA (Knowledge, Skills, Abilities) and proficiency/competency mapping across all products.
- Enable AI-assisted content generation, rubric creation, and autograding through configurable prompts.
- Allow rapid product creation through copy/clone of existing session plans and assets.
- Surface real-time KPIs and learner feedback for product decision-making.
- Validate product plans against external skills frameworks and identify gaps.

## User Story
As a **Product Developer**, I want to **author, configure, and manage end-to-end course products — including modules, instructional units, session plans, KSA mappings, AI-generated content, rubrics, and autograder configurations — within a single CLaaS Developer application**, so that **I can deliver consistent, high-quality, framework-aligned learning products efficiently and reuse them across courses**.

## Detailed Workflow

### A. Master Data & Foundation Setup (Admin)
1. Administrator configures **reference data**: supported languages, technologies, asset format types (e.g., PDF), session modes (Synchronous/Asynchronous) and sub-types.
2. Administrator configures **proficiency goals** (e.g., Basic, Advance) with display order and short reference names.
3. Administrator configures **competency levels** with banded thresholds (e.g., Basic: Fail ≤49%, Foundation 50–74%, Proficient ≥75%; Advance: Fail ≤49%, Foundation 50–59%, Proficient 60–79%, Expert ≥80%) and unique IDs.
4. Administrator configures **proficiency groupings**, linking each grouping to a competency level, proficiency goal, and the matching LMS group.
5. Administrator configures **content groupings** (categories and problem types) and **content types** per session mode, including AI generation prompts, evaluation/scoring prompts, and autograder configuration prompts.
6. Administrator configures **assessment types** linked to content categories, problem types, session modes, and sub-types.
7. Administrator configures **Technical Skills & Competencies (TSC)** records with codes, titles, categories, descriptions, related knowledge/skills, and unique IDs.

### B. Course & Product Creation
8. Administrator creates the **Course** record (internal name, public name, course code, course type, sync flag, display order).
9. Administrator creates the **Product/Module** record — either fetched via API from the Product Apps (auto-populated: product name, code, course code/name, product plan, module details) or manually if not available.
10. Administrator establishes **Course-Module Mapping** with unique identifiers and links each module to its parent course, LMS course code/link, duration, and TSC.

### C. User Administration
11. User Admin creates a **User record** (name, email; system auto-generates user ID), connects the user to relevant modules, and assigns role-based access.

### D. Product Development – KSA & IU Authoring
12. Developer adds **Module Knowledge, Skills, and Abilities** items (named, ordered, linked to the module; abilities receive unique IDs).
13. Developer creates **Instructional Units (IUs)** under each module, each with a name, display order, and unique IU ID.
14. Developer maps **IU Knowledge / Skills / Ability items**, drawing from the module-level KSA lists and ordering them within each IU.
15. Developer creates **Session Plans** per IU, specifying session mode, sub-type, content type, duration, reference number, content repository link, and display order.
16. Developer maps each **Session Plan to a Proficiency-Competency Grouping**.

### E. Content, Rubrics & Autograding
17. Developer creates **Content Mapping** records linking content items to their IU, module, proficiency-competency grouping, session mode/sub-type, content type, file format, and technologies.
18. Developer creates **Content Repository** records — uploads SharePoint files (file ID, link, name, tags), enters the AI generation prompt, and records creation method and display order.
19. Developer creates **Content Rubric** records linked to content items, IU, module, and course; attaches rubric SharePoint files and the evaluation prompt.
20. Developer creates **Autograding Configuration** linking content + rubric + module + course + session, attaches the grading script, SharePoint grading file details, and IU.

### F. Session Plan Entry & Reuse
21. Developer enters consolidated **Session Plan Config** (session plan groups, IU, session mode, category, content type, topic, day/week, content duration).
22. Developer can **Copy Session Plan** — selects a source session plan/module, selects the destination module, confirms, and the system copies links, generated files, autograder scripts, and all associated content into the new product.
23. Developer can review session plans via **Internal view** (per module, with IU links) or **External view** (public-facing links).

### G. Autograder Runtime
24. Each autograder configuration is stored with a unique `grade_conf_id`, sequence number, session reference, course code/name, module/IU details, and prompt file metadata.
25. Learner submissions are captured as `grade_sub_id` records linked to a grading configuration, with learner email, cohort code, submitted file, OpenAI response, validity flag, email-sent flag, completion flag, and retry attempt logs.
26. The system orchestrates submission → AI evaluation → score generation → email notification, logging each attempt.

### H. Analytics & Dashboards
27. Power BI dashboard displays KPI tiles: **Total Users, Active Sessions, Modules Created**.
28. Dashboard renders **Content Volume chart** (grouped by creation date and method — uploaded, AI-generated, SharePoint link).
29. Dashboard renders **User Distribution chart** (Admin / User / Technology).
30. Dashboard renders **Recent Activity table** (5-row summary of module, session, and content counts).
31. **Learner Feedback report** is fetched from CLaaS Manager and rendered inside an embedded Power BI iframe for interactive analysis.

### I. Curriculum Framework Alignment
32. Reviewer configures the **country**, loads the **Product Plan**, and loads the relevant **skills framework**.
33. The system performs an **Alignment Check**, highlights aligned items and gaps, and surfaces **recommendations** to close identified gaps.

## Acceptance Criteria

### Master Data & Configuration
- All reference/master data (languages, technologies, session modes, asset formats, proficiency goals, competency levels, content groupings, content types, assessment types, TSCs) supports Create, Read, Update, Deactivate, ordering, and unique ID assignment.
- Competency level thresholds enforce the documented bands for Basic and Advance goals.
- Content types capture AI generation prompts, evaluation prompts, and autograder prompts as distinct fields, plus an "AI-generatable" flag.

### Course / Product / Module
- Modules can be ingested via API from Product Apps OR created manually if not present.
- Each module must be linked to a parent course, an LMS course code/link, a duration, and at least one TSC entry.
- Course-Module mappings produce a unique identifier and prevent duplicates.

### KSA & IU Mapping
- Knowledge, Skill, and Ability items can only be assigned to an IU if they exist in the parent module's KSA list.
- Each IU has a unique ID and an ordered position within its module.
- Session plans must be linked to an IU and to a proficiency-competency grouping before they can be published.

### Session Plan Copy
- Copying a session plan duplicates all linked content (links, generated files, autograder script, rubrics) into the destination module without modifying the source.
- The user must explicitly confirm the destination before the copy executes.

### Content, Rubrics, Autograder
- Content records must reference SharePoint file ID, link, name, and tags.
- Rubric records must be linked to a content item, IU, module, and course.
- Autograder configurations must reference a content item, its rubric, the module, course, session, and a grading script before they can be activated.
- Submissions log every processing attempt, OpenAI response validity, email-sent status, and completion status.

### User Administration & RBAC
- User IDs are auto-generated and unique.
- Role assignment is per-module; users only see modules they are assigned to.

### Dashboards
- KPI counts (Total Users, Active Sessions, Modules Created) match the underlying records and refresh on dashboard load.
- Content Volume chart correctly attributes records to upload, AI-generated, and SharePoint link methods.
- Recent Activity table shows the five documented counts.
- Learner Feedback Power BI report renders within an embedded iframe and supports interactive filtering.

### Curriculum Framework Alignment
- Alignment check returns a visual highlight of aligned vs. gap items.
- Each identified gap produces at least one actionable recommendation.

## Assumptions & Constraints
- Product master data may be sourced via API from an external Product Apps system; manual creation is a fallback only when the API does not return a record.
- SharePoint is the canonical file store for content, rubrics, and grading artifacts.
- The autograder relies on OpenAI for evaluation; failures must be retried and logged rather than silently dropped.
- Power BI is the analytics layer; Learner Feedback originates in CLaaS Manager and is consumed read-only here.
- LMS integration is listed under "Future Enhancements" and is out of scope for the current release.
- Role-Based Access (RBA) is enforced at the module level.
- All ordered lists (modes, goals, levels, IUs, etc.) require an explicit display-order value to control sequencing in UI and exports.

--- FEATURE LIST SUMMARY ---
This solution enables curriculum developers and administrators to author, configure, and manage end-to-end course products within the CLaaS Developer platform. Primary actors include the CLaaS Administrator, Product Developer, User Administrator, Curriculum Framework Reviewer, and Analytics Consumer. The core flow moves from master/reference data setup, through course and module creation, user administration, KSA and IU authoring, content, rubric and autograder configuration, session plan reuse, runtime autograding of learner submissions, and finally analytics dashboards and skills-framework alignment review. The Master Data Configuration cluster holds reference/lookup data (languages, technologies, session modes, asset formats, proficiency goals, competency levels, content/assessment types, TSCs) reused everywhere. Total of 18 rows covering authoring, autograding, dashboards, and framework alignment.

Feature Clusters & Features:
• Master Data Configuration
  - 1. Reference Catalogs Management — Maintains shared lookups for languages, technologies, asset format types, and session modes used across all products.
  - 2. Proficiency & Competency Configuration — Defines proficiency goals, banded competency levels, and proficiency groupings linked to LMS groups for consistent learner evaluation.
  - 3. Content & Assessment Type Setup — Configures content groupings, content types with AI prompts, and assessment types tied to session modes and categories.
  - 4. Technical Skills & Competencies (TSC) Registry — Captures TSC codes, titles, categories, and related knowledge/skills used for tagging modules and alignment checks.
• Course & Product Setup
  - 5. Course Record Management — Creates and maintains course master records with internal/public names, codes, types, and display order.
  - 6. Product/Module Creation & API Ingestion — Pulls module data via API from Product Apps with manual fallback, capturing product plan and module details.
  - 7. Course-Module Mapping — Links modules to parent courses with unique identifiers, LMS course code/link, duration, and TSC associations.
• User Administration
  - 8. User & Module-level RBAC — Creates user accounts, auto-generates user IDs, and assigns role-based access at the module level.
• KSA & Instructional Unit Authoring
  - 9. Module KSA Authoring — Lets developers add ordered Knowledge, Skill, and Ability items at the module level for downstream IU mapping.
  - 10. Instructional Unit Management — Creates IUs under modules with unique IDs, ordered positions, and KSA item mappings drawn from the parent module.
  - 11. Session Plan Authoring — Creates session plans per IU with mode, sub-type, content type, duration, repository link, and proficiency-competency grouping.
• Content, Rubrics & Autograder Setup
  - 12. Content Mapping & Repository — Links content items to IU/module/grouping and stores SharePoint files, AI generation prompts, and creation method.
  - 13. Content Rubric Configuration — Creates rubrics tied to content, IU, module, and course with SharePoint rubric files and evaluation prompts.
  - 14. Autograder Configuration — Links content, rubric, module, course, and session with a grading script and prompt metadata for activation.
• Session Plan Reuse & Review
  - 15. Session Plan Copy & Views — Copies a source session plan with all linked assets to a destination module and offers internal/external review views.
• Autograder Runtime
  - 16. Submission Processing & Notification — Captures learner submissions, runs OpenAI evaluation, logs retries, and sends email notifications with completion status.
• Analytics & Dashboards
  - 17. Power BI KPI & Feedback Dashboards — Renders KPI tiles, content volume, user distribution, recent activity, and embedded learner feedback reports.
• Curriculum Framework Alignment
  - 18. Skills Framework Alignment Check — Loads product plans against country-specific skills frameworks and surfaces gaps with actionable recommendations.

--- FEATURE LIST (18 features across 9 clusters) ---

#1 | Cluster: Master Data Configuration | Feature: Reference Catalogs Management
  Description: Provides CRUD admin screens for shared lookup catalogs used everywhere in the platform. Ensures consistent naming, ordering, and unique identifiers for all reference values.
  Workflow:
    1. Admin opens reference data admin screen.
    2. Selects catalog (languages, technologies, asset formats, session modes/sub-types).
    3. Creates/edits/deactivates entries with display order.
    4. System enforces unique IDs and ordering.
    5. Saved entries become available to downstream forms.
  Table:       ref_catalog_items
  Columns:     id (bigint, pk), catalog_type (varchar 50), code (varchar 50), name (varchar 255), display_order (int), parent_id (bigint, fk), is_active (boolean), created_at (timestamp)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#2 | Cluster: Master Data Configuration | Feature: Proficiency & Competency Configuration
  Description: Configures proficiency goals, competency level thresholds, and proficiency groupings used to evaluate learner performance. Links each grouping to a corresponding LMS group for consistent scoring.
  Workflow:
    1. Admin defines proficiency goals (Basic, Advance) with display order.
    2. Admin defines competency levels with banded thresholds.
    3. Admin creates proficiency groupings linking goal + level + LMS group.
    4. System validates threshold bands.
    5. Groupings become selectable in session plans.
  Table:       proficiency_groupings
  Columns:     id (bigint, pk), goal_id (bigint, fk), level_id (bigint, fk), lms_group_code (varchar 100), threshold_bands (json), display_order (int), is_active (boolean)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#3 | Cluster: Master Data Configuration | Feature: Content & Assessment Type Setup
  Description: Captures content groupings, content types with embedded AI prompts, and assessment types tied to session modes. Drives downstream content authoring and AI-assisted generation.
  Workflow:
    1. Admin creates content groupings (categories, problem types).
    2. Admin defines content types per session mode with AI generation, evaluation, and autograder prompts.
    3. Admin sets AI-generatable flag.
    4. Admin defines assessment types linked to content categories and session modes.
    5. Saved types are reusable in content mapping.
  Table:       content_types
  Columns:     id (bigint, pk), grouping_id (bigint, fk), session_mode_id (bigint, fk), name (varchar 255), ai_gen_prompt (text), eval_prompt (text), autograder_prompt (text), is_ai_generatable (boolean)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#4 | Cluster: Master Data Configuration | Feature: Technical Skills & Competencies (TSC) Registry
  Description: Maintains a registry of Technical Skills & Competencies with codes, descriptions, and related knowledge/skills. Used to tag modules and to support skills framework alignment checks.
  Workflow:
    1. Admin opens TSC admin screen.
    2. Creates TSC record with code, title, category, description.
    3. Adds related knowledge and skills.
    4. System assigns unique TSC ID.
    5. TSC becomes available for module tagging and framework alignment.
  Table:       tsc_records
  Columns:     id (bigint, pk), tsc_code (varchar 50), title (varchar 255), category (varchar 100), description (text), related_knowledge (text), related_skills (text), is_active (boolean)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#5 | Cluster: Course & Product Setup | Feature: Course Record Management
  Description: Creates and maintains the top-level Course master records that anchor all modules and content. Ensures unique codes and ordered display for catalog presentation.
  Workflow:
    1. Admin opens course admin screen.
    2. Enters internal name, public name, course code, type, sync flag, display order.
    3. System validates unique course code.
    4. Saves course record.
    5. Course becomes available for module mapping.
  Table:       courses
  Columns:     id (bigint, pk), internal_name (varchar 255), public_name (varchar 255), course_code (varchar 50, unique), course_type (varchar 50), is_sync (boolean), display_order (int), created_at (timestamp)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#6 | Cluster: Course & Product Setup | Feature: Product/Module Creation & API Ingestion
  Description: Creates product/module records by ingesting from the external Product Apps API or via manual fallback. Standardizes product metadata across the platform.
  Workflow:
    1. Admin requests product fetch via API to Product Apps.
    2. If found, system auto-populates product/module fields.
    3. If not found, admin creates module manually.
    4. Admin completes product plan and module details.
    5. Saves module record.
  Table:       modules
  Columns:     id (bigint, pk), product_code (varchar 50), product_name (varchar 255), course_code (varchar 50), product_plan (text), source (varchar 20), created_at (timestamp), is_active (boolean)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#7 | Cluster: Course & Product Setup | Feature: Course-Module Mapping
  Description: Links each module to its parent course, LMS reference, duration, and at least one TSC. Enforces uniqueness to prevent duplicate mappings.
  Workflow:
    1. Admin selects parent course and module.
    2. Enters LMS course code/link, duration.
    3. Selects one or more TSC entries.
    4. System generates unique mapping ID and prevents duplicates.
    5. Mapping persisted.
  Table:       course_module_mappings
  Columns:     id (bigint, pk), course_id (bigint, fk), module_id (bigint, fk), lms_course_code (varchar 100), lms_link (varchar 500), duration_hours (int), tsc_ids (json), unique_mapping_id (varchar 50)
  Actor:       CLaaS Administrator
  AI Agent:    None
  ----
#8 | Cluster: User Administration | Feature: User & Module-level RBAC
  Description: Creates user accounts with auto-generated unique IDs and assigns role-based access at the module level. Ensures users only see modules they are explicitly assigned to.
  Workflow:
    1. User Admin opens user admin screen.
    2. Enters name and email; system auto-generates user ID.
    3. Admin selects modules to grant access to.
    4. Admin assigns roles per module.
    5. System enforces module-level visibility on login.
  Table:       user_module_roles
  Columns:     id (bigint, pk), user_id (bigint, fk), module_id (bigint, fk), role (varchar 50), assigned_by (bigint, fk), assigned_at (timestamp), is_active (boolean)
  Actor:       User Administrator
  AI Agent:    None
  ----
#9 | Cluster: KSA & Instructional Unit Authoring | Feature: Module KSA Authoring
  Description: Allows developers to add ordered Knowledge, Skills, and Abilities at the module level, forming the KSA pool for downstream IU mappings. Abilities receive unique system-generated IDs.
  Workflow:
    1. Developer opens module KSA screen.
    2. Adds Knowledge items with name and order.
    3. Adds Skill items with name and order.
    4. Adds Ability items; system assigns unique IDs.
    5. Saves the module-level KSA list.
  Table:       module_ksa_items
  Columns:     id (bigint, pk), module_id (bigint, fk), ksa_type (varchar 20), name (varchar 255), display_order (int), unique_ksa_id (varchar 50), created_at (timestamp)
  Actor:       Product Developer
  AI Agent:    None
  ----
#10 | Cluster: KSA & Instructional Unit Authoring | Feature: Instructional Unit Management
  Description: Creates Instructional Units under modules with unique IDs and ordered positions. Restricts IU KSA mappings to items existing in the parent module's KSA pool.
  Workflow:
    1. Developer creates IU under a module with name and display order.
    2. System assigns unique IU ID.
    3. Developer maps KSA items from module pool into the IU.
    4. Developer orders KSA items within IU.
    5. Saves the IU and its mappings.
  Table:       instructional_units
  Columns:     id (bigint, pk), module_id (bigint, fk), iu_name (varchar 255), iu_unique_id (varchar 50), display_order (int), ksa_mapping_ids (json), created_at (timestamp)
  Actor:       Product Developer
  AI Agent:    None
  ----
#11 | Cluster: KSA & Instructional Unit Authoring | Feature: Session Plan Authoring
  Description: Creates session plans per IU with mode, content type, duration, and repository link. Requires mapping to a proficiency-competency grouping before the plan can be published.
  Workflow:
    1. Developer creates session plan under an IU.
    2. Selects session mode, sub-type, content type.
    3. Enters duration, reference number, content repository link, display order.
    4. Maps to a proficiency-competency grouping.
    5. Saves; plan must be linked to IU + grouping before publish.
  Table:       session_plans
  Columns:     id (bigint, pk), iu_id (bigint, fk), session_mode_id (bigint, fk), sub_type_id (bigint, fk), content_type_id (bigint, fk), prof_comp_grouping_id (bigint, fk), duration_min (int), ref_number (varchar 50), repo_link (varchar 500), display_order (int)
  Actor:       Product Developer
  AI Agent:    None
  ----
#12 | Cluster: Content, Rubrics & Autograder Setup | Feature: Content Mapping & Repository
  Description: Links content items to IU/module/grouping/session metadata and stores SharePoint file references plus AI generation prompts. Tracks creation method (uploaded, AI-generated, SharePoint link).
  Workflow:
    1. Developer creates content mapping linking IU, module, grouping, content type.
    2. Uploads SharePoint file; captures file ID, link, name, tags.
    3. Enters AI generation prompt and creation method.
    4. Sets display order.
    5. Saves content record.
  Table:       content_items
  Columns:     id (bigint, pk), iu_id (bigint, fk), module_id (bigint, fk), prof_comp_grouping_id (bigint, fk), session_mode_id (bigint, fk), sp_file_id (varchar 100), sp_link (varchar 500), tags (json), creation_method (varchar 50), display_order (int)
  Actor:       Product Developer
  AI Agent:    None
  ----
#13 | Cluster: Content, Rubrics & Autograder Setup | Feature: Content Rubric Configuration
  Description: Creates rubric records tied to a content item, IU, module, and course with SharePoint rubric files and evaluation prompts. Ensures every rubric is fully linked to its content and structure.
  Workflow:
    1. Developer creates rubric record linked to content, IU, module, course.
    2. Attaches rubric SharePoint file (id, link, name).
    3. Enters evaluation prompt.
    4. Sets display order.
    5. Saves rubric record.
  Table:       content_rubrics
  Columns:     id (bigint, pk), content_id (bigint, fk), iu_id (bigint, fk), module_id (bigint, fk), course_id (bigint, fk), rubric_sp_file_id (varchar 100), rubric_sp_link (varchar 500), eval_prompt (text)
  Actor:       Product Developer
  AI Agent:    None
  ----
#14 | Cluster: Content, Rubrics & Autograder Setup | Feature: Autograder Configuration
  Description: Defines an autograder configuration that ties content, rubric, module, course, and session to a grading script. Required references must be present before the configuration can be activated.
  Workflow:
    1. Developer creates autograder config linking content, rubric, module, course, session.
    2. Attaches grading script and SharePoint grading file metadata.
    3. Links to IU.
    4. System assigns unique grade_conf_id and sequence number.
    5. Activates configuration when complete.
  Table:       autograder_configs
  Columns:     grade_conf_id (varchar 50, pk), seq_no (int), content_id (bigint, fk), rubric_id (bigint, fk), module_id (bigint, fk), course_id (bigint, fk), session_id (bigint, fk), iu_id (bigint, fk), grading_script_link (varchar 500), is_active (boolean)
  Actor:       Product Developer
  AI Agent:    None
  ----
#15 | Cluster: Session Plan Reuse & Review | Feature: Session Plan Copy & Views
  Description: Copies a source session plan with all linked content, autograder scripts, and rubrics into a destination module without modifying the source. Provides internal and external review views of session plans.
  Workflow:
    1. Developer selects source session plan/module.
    2. Selects destination module.
    3. Confirms copy operation explicitly.
    4. System duplicates links, generated files, autograder scripts, rubrics into destination.
    5. Developer reviews via internal or external view.
  Table:       session_plan_copies
  Columns:     id (bigint, pk), source_session_plan_id (bigint, fk), dest_module_id (bigint, fk), copied_by (bigint, fk), copied_at (timestamp), copy_status (varchar 30), copied_artifact_ids (json)
  Actor:       Product Developer
  AI Agent:    None
  ----
#16 | Cluster: Autograder Runtime | Feature: Submission Processing & Notification
  Description: Captures learner submissions and orchestrates AI evaluation, score generation, and email notification. Logs every retry attempt, response validity, and completion status to ensure no submission is silently dropped.
  Workflow:
    1. Learner submission captured with file, learner email, cohort.
    2. System creates grade_sub_id linked to grading config.
    3. Sends submission to OpenAI for evaluation.
    4. Logs response, validity flag, retry attempts.
    5. Generates score, sends email, marks completion flag.
  Table:       grading_submissions
  Columns:     grade_sub_id (varchar 50, pk), grade_conf_id (varchar 50, fk), learner_email (varchar 255), cohort_code (varchar 50), submitted_file_link (varchar 500), openai_response (text), is_valid (boolean), email_sent (boolean), is_complete (boolean), retry_attempts (int)
  Actor:       Learner / System
  AI Agent:    None
  ----
#17 | Cluster: Analytics & Dashboards | Feature: Power BI KPI & Feedback Dashboards
  Description: Provides Power BI dashboards with KPI tiles, content volume, user distribution, and recent activity, plus an embedded learner feedback report from CLaaS Manager. Supports interactive analytical exploration for product owners.
  Workflow:
    1. Analytics consumer opens dashboard page.
    2. System loads KPI tiles (Total Users, Active Sessions, Modules Created).
    3. Renders content volume chart by creation date and method.
    4. Renders user distribution and recent activity table.
    5. Embeds learner feedback Power BI report via iframe for interactive filtering.
  Table:       dashboard_metrics_cache
  Columns:     id (bigint, pk), metric_name (varchar 100), metric_value (decimal), dimension_key (varchar 100), dimension_value (varchar 255), refreshed_at (timestamp), source_system (varchar 50)
  Actor:       Analytics Consumer
  AI Agent:    None
  ----
#18 | Cluster: Curriculum Framework Alignment | Feature: Skills Framework Alignment Check
  Description: Validates a product plan against an external national/skills framework, visually highlighting aligned items and gaps. Produces at least one actionable recommendation per identified gap.
  Workflow:
    1. Reviewer selects country and loads product plan.
    2. Reviewer loads applicable skills framework.
    3. System runs alignment check between plan and framework.
    4. Highlights aligned items and gaps visually.
    5. Generates actionable recommendations for each gap.
  Table:       framework_alignment_runs
  Columns:     id (bigint, pk), product_plan_id (bigint, fk), framework_code (varchar 50), country_code (varchar 10), aligned_items (json), gap_items (json), recommendations (json), run_at (timestamp)
  Actor:       Curriculum Framework Reviewer
  AI Agent:    None
  ----

==================================================
 END OF STORY EXPORT
==================================================
