> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kibocommerce.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Content Models and Content Entries

> Understanding the foundation of Kibo CMS — content models and entries.

In this guide, we'll explore the foundational concepts of Kibo CMS: content models and content entries. Understanding these concepts is essential for working with any headless CMS, and Kibo CMS provides a powerful and flexible implementation.

**What you'll learn:**

* What content models are and how they work
* What content entries are
* The relationship between models and entries

## What Are Content Models?

A **content model** is a blueprint or schema that defines the structure of your content. Think of it as a template that specifies what fields your content will have and what type of data each field can contain.

Content models are similar to:

* **Database tables** in traditional databases (defining columns and their types)
* **Classes** in object-oriented programming (defining properties and their types)
* **Schemas** in GraphQL (defining types and their fields)

### Example: Blog Post Content Model

Let's say you're building a blog. Your "Blog Post" content model might include:

* **Title** (Text field)
* **Slug** (Text field)
* **Author** (Reference to an Author model)
* **Featured Image** (File field)
* **Body** (Rich text field)
* **Category** (Reference to a Category model)
* **Tags** (Multiple references to a Tag model)
* **Published Date** (DateTime field)
* **Is Featured** (Boolean field)

This model defines the structure, but it doesn't contain any actual blog posts — it just defines what a blog post should look like.

<Note>
  Content models are reusable blueprints. Once you create a "Blog Post" model, you can create
  hundreds or thousands of individual blog posts (entries) based on that model.
</Note>

## What Are Content Entries?

A **content entry** is an instance of a content model — it's the actual content created using the structure defined by the model.

Using our blog post example:

* The **content model** defines what fields a blog post has (title, body, author, etc.)
* Each **content entry** is an actual blog post with real values for those fields

### Example: Blog Post Entries

Based on the "Blog Post" model above, you might have entries like:

**Entry 1:**

* Title: "Getting Started with Kibo CMS"
* Slug: "getting-started-with-kibo-cms"
* Author: "John Doe"
* Body: "In this post, we'll explore..."
* Published Date: "2024-01-15"

**Entry 2:**

* Title: "Advanced Headless CMS Patterns"
* Slug: "advanced-headless-cms-patterns"
* Author: "Jane Smith"
* Body: "Let's dive into advanced patterns..."
* Published Date: "2024-01-20"

Each entry contains actual data that follows the structure defined by the model.

## The Relationship Between Models and Entries

The relationship is straightforward:

```mermaid theme={null}
flowchart TD
    model["Content Model<br/>(Blueprint)"]
    entries["Content Entries<br/>(Instances)"]
    model --> entries
```

* **One model** → **Many entries**
* The model defines the structure
* Entries contain the actual data

Think of it like a form:

* The **model** is the blank form template
* Each **entry** is a filled-out form

<Tip>
  Content models are like cookie cutters — they define the shape. Content entries are like the
  actual cookies — each one has the same shape but different flavor, size, or decorations.
</Tip>

## Field Types in Kibo CMS

Kibo CMS provides a rich set of field types you can use in your content models:

### Basic Fields

* **Text** — Short text (single line)
* **Long Text** — Multi-line text
* **Rich Text** — Formatted text with headings, lists, links, etc.
* **Number** — Numeric values
* **Boolean** — True/false values
* **DateTime** — Dates and times

### Advanced Fields

* **File** — Upload and reference files (images, PDFs, etc.)
* **Reference** — Link to entries from other models
* **Object** — Nested field groups
* **Dynamic Zone** — Flexible content blocks (great for page builders)

### List Fields

Most field types can be configured as lists (arrays) to store multiple values. For example:

* A list of tags
* Multiple authors
* A gallery of images

## Why This Matters

Understanding content models and entries is crucial because:

1. **Structure First** — You define your content structure (models) before creating content (entries)
2. **Type Safety** — Models ensure your content has the correct structure and data types
3. **API Generation** — Kibo CMS automatically generates GraphQL APIs based on your models
4. **Validation** — Models define validation rules that entries must follow
5. **Reusability** — One model can be used to create thousands of entries

<Note>
  When you create a content model in Kibo CMS, the system automatically generates GraphQL queries
  and mutations for creating, reading, updating, and deleting entries. You don't need to write any
  backend code.
</Note>

## Content Models in Practice

In the real world, you might have content models for:

* **E-commerce:** Product, Category, Brand, Review, Order
* **Blog:** Post, Author, Category, Tag, Comment
* **Documentation:** Article, Section, Code Example, Tutorial
* **Marketing:** Landing Page, Feature, Testimonial, Case Study
* **Media:** Video, Podcast, Episode, Playlist

Each of these models would define the structure, and you'd create individual entries for each product, blog post, article, etc.

## Next Steps

Now that you understand the basics of content models and entries, you're ready to:

* [Create your first content model](/pages/cms-create-content-model) through the UI
* [Create a content entry](/pages/cms-create-content-entry) using your model
* Explore [content entry revisions](/pages/cms-content-entry-revisions) to understand how Kibo CMS tracks changes

## Summary

* **Content models** are blueprints that define structure and field types
* **Content entries** are instances containing actual data
* **One model** can have many entries
* Kibo CMS provides rich field types for building flexible content structures
* Models automatically generate GraphQL APIs