Structures are the foundation of your curriculum in CurryCMS. A well-designed structure makes content creation intuitive, maintains consistency, and ensures your curriculum can scale as your needs grow.
Before You Begin
You need:
- Admin role in your account
- Clear understanding of your curriculum organization
- List of content types you'll need (Course, Unit, Lesson, etc.)
- Understanding of relationships between content types
What is a Structure?
A structure defines:
- Node types: What kinds of content exist (Course, Unit, Lesson, Activity)
- Hierarchy rules: Which types can contain which other types
- Attributes: What data each type captures
- Constraints: Rules about relationships and nesting
Think of a structure as a template that defines the shape of curricula, not the content itself.
Example:
```
Structure: K-12 Mathematics
├── Node Type: Course (root)
├── Node Type: Unit (child of Course)
├── Node Type: Lesson (child of Unit)
└── Node Type: Activity (child of Lesson)
Hierarchy Rules:
- Course can contain Units
- Unit can contain Lessons
- Lesson can contain Activities
```
Creating a Structure
Step 1: Plan Your Structure
Before creating, answer:
What content types do you need?
- Common: Course, Unit, Lesson, Activity, Assessment
- Specialized: Section, Module, Topic, Exercise, etc.
How do they relate?
- Linear: Course → Unit → Lesson → Activity
- Flexible: Module → Module → Content
- Mixed: Multiple child types at each level
What attributes do types need?
- All types: Title, Description
- Lessons: Duration, Learning Objectives
- Activities: Interactivity Type, Materials
Step 2: Create the Structure
- Navigate to Schema → Structures in the navigation
- Click Create Structure
- Fill out the form:
- Name (required): "K-12 Mathematics" or "Course-Unit-Lesson Structure"
- Description (optional): "Standard 4-level hierarchy for K-12 math curricula"
- Click Create Structure
After creation:
- You're taken to the structure detail view
- The structure has no node types yet
- You'll add node types and configure hierarchy next
Step 3: Add Node Types
See Managing Node Types for detailed instructions.
Quick overview:
1. Click Add Node Type
2. Enter name and display name
3. Mark as root if it's a top-level type
4. Configure attributes
5. Define allowed children
Step 4: Configure Hierarchy
Define parent-child relationships:
- For each node type, specify Allowed Children
- Select which types can be children
- This enforces valid content structure
Example configuration:
- Course: Allowed children = [Unit]
- Unit: Allowed children = [Lesson]
- Lesson: Allowed children = [Activity, Assessment]
- Activity: Allowed children =
Structure Design Patterns
Pattern 1: Linear Hierarchy
Structure:
Course → Unit → Lesson → Activity
Best for:
- Traditional sequential curricula
- Clear learning progressions
- Simple to understand
Example use:
- K-12 textbook replacements
- Online courses with fixed structure
- Training programs
Pros:
- Intuitive for authors
- Easy to navigate
- Clear organization
Cons:
- Not flexible
- Can't handle alternative organizations
Pattern 2: Branching Hierarchy
Structure:
Course
└── Unit
├── Lesson
│ ├── Activity
│ └── Assessment
└── Project
Best for:
- Curricula with varied content types
- Including assessments and projects
- Differentiated instruction
Example use:
- College courses
- Professional development
- Blended learning programs
Pros:
- Flexible content types
- Can include multiple assessment types
- Supports varied pedagogy
Cons:
- More complex for authors
- Requires careful planning
Pattern 3: Flexible Self-Nesting
Structure:
Module
├── Module (nested)
│ ├── Module (nested deeper)
│ └── Content
└── Content
Best for:
- Highly variable organization
- Different depths per curriculum
- Adaptive learning paths
Example use:
- OER repositories
- Competency-based education
- Micro-learning platforms
Pros:
- Maximum flexibility
- Authors control depth
- Reusable modules
Cons:
- Can become unmanageable
- Hard to enforce consistency
- Navigation complexity
Pattern 4: Component-Based
Structure:
Section → [Any of: Video, Reading, Quiz, Discussion, Exercise]
Best for:
- Mix-and-match content
- Component libraries
- Authoring flexibility
Example use:
- eLearning platforms
- Modular curriculum design
- Content libraries
Pros:
- High reusability
- Author creativity
- Easy to rearrange
Cons:
- Less prescribed organization
- May lack coherence
- Requires disciplined authoring
Attribute Planning
Attribute Strategy
Universal attributes (all node types):
- Title
- Description
- Author
- Last Modified
Type-specific attributes (varies by type):
- Lessons: Duration, Learning Objectives
- Activities: Materials Needed, Interactivity Level
- Assessments: Question Count, Time Limit
Bundle approach:
- Create "Basic Info" bundle with universal attributes
- Create specialized bundles per type
- Apply bundles to appropriate node types
See Attribute Bundles for details.
Modifying Existing Structures
Understanding Impact
Safe changes (no data loss):
- Adding new node types
- Adding new attributes
- Adding new allowed children
- Updating names and descriptions
Potentially destructive:
- Removing attributes (data deleted)
- Removing node types with content (must delete content first)
- Removing allowed children (can't add new, but existing content unaffected)
Making Safe Changes
- Open the structure
- Navigate to the element to modify
- Make your change
- Save
- Changes apply to all curricula using this structure
Best practice: Test on a cloned structure first.
Handling Destructive Changes
Before removing attributes:
1. Check if any content uses the attribute
2. Export or migrate data if needed
3. Communicate changes to authors
4. Remove the attribute
Before removing node types:
1. Verify no content nodes of that type exist
2. Delete all content nodes of that type first
3. Then remove the node type from structure
Before removing allowed children:
1. Understand existing content won't be deleted
2. Authors can't add new children of that type
3. Existing children remain valid
Structure Variants
Advanced feature for creating compatible variations.
What Are Structure Variants?
A structure variant inherits from a parent structure but can add:
- New node types
- Additional attributes
- Extended hierarchy rules
Example:
- Base: Course → Unit → Lesson
- Variant: Course → Unit → Lesson → Lab Activity (adds Lab Activity type)
When to Use Structure Variants
Use when:
- Regional requirements need additional node types
- Different curricula need specialized attributes
- You want to maintain compatibility with parent structure
Don't use when:
- You need a completely different organization
- Changes are minor (add to base structure instead)
- You don't understand inheritance implications
Creating a Structure Variant
- Open the parent structure
- Click Create Variant
- Enter name and description
- Add your specialized node types/attributes
- Save
Result:
- Variant inherits all parent node types
- Variant can add new types
- Curricula can choose base or variant
Cloning Structures
Create a copy to test changes or create similar structures.
When to Clone
Clone for:
- Testing major changes before applying to production
- Creating a similar structure for different subject
- Starting point for experimentation
Example:
- Clone "K-12 Mathematics" to create "K-12 Science"
- Modify node types and attributes for science-specific needs
- Keep math structure unchanged
How to Clone
- Open the structure to clone
- Click Clone Structure
- Enter new name: "Copy of [Original Name]" or custom name
- Description automatically includes "Cloned from..."
- Click Clone
Result:
- Complete copy with all node types, attributes, and hierarchy
- No connection to original (not a variant)
- Modify freely without affecting original
Deleting Structures
Prerequisites
You cannot delete a structure if:
- Any curricula use it
- Any structure variants inherit from it
How to Delete
- Verify no curricula use the structure
- Delete or migrate all curricula first
- Open the structure
- Click Delete Structure
- Confirm deletion
⚠️ Warning: Deletion is permanent and cannot be undone.
Alternative to Deletion
Instead of deleting:
- Archive: Rename to "ARCHIVED - [Name]" and document why
- Hide: Mark as inactive (if feature available)
- Migrate: Move curricula to new structure before deleting old
Best Practices
Start Simple
Begin with:
- 3-4 node types maximum
- Linear hierarchy
- Basic attributes only
Expand later:
- Add specialized types as needed
- Introduce branching when requirements emerge
- Keep it minimal until you understand needs
Why: Over-complex structures confuse authors and create maintenance burden.
Plan for Growth
Design for:
- Future content types (leave room in hierarchy)
- Attribute evolution (use bundles for flexibility)
- Variant needs (will regional versions need extensions?)
Example:
- Instead of: Lesson → Activity (rigid)
- Use: Lesson → Activity OR Assessment
Use Descriptive Names
Node type names should be:
- ✅ "Course" not "C"
- ✅ "Learning Activity" not "LA"
- ✅ "Formative Assessment" not "Assessment1"
Why: Authors see these names daily. Clarity matters.
Document Your Design
Structure description should include:
- Purpose and use case
- Node type relationships
- Intended use patterns
- Any special rules or conventions
Example:
```
K-12 Mathematics Structure
4-level hierarchy for standards-aligned K-12 math curricula.
Node Types:
- Course: Full-year curriculum (e.g., "Grade 3 Math")
- Unit: Multi-week instructional unit
- Lesson: Single class period
- Activity: 10-15 minute engagement
Conventions:
- Units align to 1-3 standards
- Lessons align to specific standards
- Activities for practice, not direct instruction
```
Involve Authors Early
Get feedback from:
- Content authors who will use the structure
- Curriculum directors with requirements
- Subject matter experts
Ask:
- Does this match how you think about content?
- What's missing?
- What seems unnecessary?
Why: Structures designed in isolation often miss real-world needs.
Version Structure Names
If you expect evolution:
- "K-12 Math Structure v2"
- "Course Template 2024"
- "Standard Structure (Revised)"
Why: Makes it clear which version curricula use and when changes happened.
Common Questions
Can I change a curriculum's structure after creation?
No. Structures are locked when curricula are created. To change, create new curriculum with new structure and migrate content manually.
What happens to existing content when I modify a structure?
Adding: New types/attributes available immediately
Removing: Existing content unaffected but can't add new nodes of removed types
Deleting attributes: Data is lost
How many structures should I have?
Typical:
- 1-3 for most organizations
- One per content domain (Math, Science, ELA)
- Or one universal flexible structure
Avoid: Dozens of nearly-identical structures. Use variants instead.
Can authors see structures?
Authors see node types and attributes, not the "structure" abstraction. Admins manage structures; authors use them.
Should I create one structure or many?
One structure when:
- Content organization is similar across subjects
- You want consistency
- Maintenance simplicity is priority
Multiple structures when:
- Subjects have fundamentally different organization
- Requirements vary significantly
- Each structure serves distinct purpose
Can I merge two structures?
No automatic merge. You must:
- Create new combined structure manually
- Migrate curricula one at a time
- Or use one structure and deprecate the other
What if I made a mistake in the structure?
If no curricula exist yet: Delete and recreate
If curricula exist:
- Clone structure to create corrected version
- Create new curricula with corrected structure
- Migrate content manually
Troubleshooting
"Cannot delete structure: curricula exist"
Find and delete or reassign all curricula using this structure first. Use the curricula list filtered by structure.
Changes to structure not appearing in curriculum
Refresh the curriculum page. Some changes require reload to display.
Authors can't add certain content types
Check Allowed Children configuration. The parent node type must explicitly allow that child type.
Attributes not showing in node edit form
Verify:
- Attribute bundle is assigned to node type
- Bundle contains the attributes
- Attribute is not hidden or conditional
Structure list shows outdated information
Clear browser cache or hard refresh (Cmd/Ctrl + Shift + R).
Next Steps
After designing your structure:
- Managing Node Types - Configure individual node types
- Attribute Bundles - Create reusable attribute sets
- Creating Curricula - Start building content with your structure
Related Documentation:
- Admin Overview - Your administrative capabilities
- Managing Node Types - Configure content types
- Attribute Bundles - Create reusable attributes
- Team Management - Manage user roles