How to create and manage content models in Contentful step by step

If you’re building a site or app and want your content to be flexible, structured, and not a complete mess, you’ll hear about Contentful. This guide is for people who need to set up and manage content models in Contentful—whether you’re a developer, a content strategist, or someone who drew the short straw. We’ll skip the fluff and get straight to what you need to know to make Contentful work for you, not the other way around.

What’s a content model, really?

Before we get into button-clicking, let’s get clear: a content model is just the blueprint for your content. It tells Contentful what kinds of content you have (blog posts, authors, products, whatever) and what fields each type has (title, image, price, etc.). If you half-bake this step, you’ll regret it every time you try to update your site or integrate new features.

Here’s what you should keep in mind: - Content models are not set-and-forget. You’ll need to update them as your needs change. - Over-complicating is easy. Start simple and add as you go. - Fields should map to real-world data. Don’t invent complexity you don’t actually need.

Step 1: Get your bearings in Contentful

If you’re new to Contentful, sign up and create a free space. You’ll need a “space” for your project, which is just their word for a workspace.

  • Go to your Contentful dashboard
  • Click “Add space”
  • Name your space (don’t overthink it)

Once inside, click on “Content model” in the left sidebar. This is where all the action happens.

Pro tip: If you’re part of a team, get everyone to agree on naming conventions now. Otherwise, your “HeroImage” and “hero_image” fields will multiply like rabbits.

Step 2: Plan your content types (before you touch the UI)

Don’t start clicking “Add content type” yet. Planning saves you headaches later, trust me.

Ask yourself: - What kinds of content do I need? (Blog post, author, category, product, etc.) - What fields does each type need? (Text, images, dates, references to other types) - Which fields are required? Which are optional? - Will any content types reference each other? (For example, a blog post has an author)

Sketch it out on paper or in a doc. If you’re working with others, now’s the time to argue about what a “tag” really is.

What to skip: Don’t model every possible future scenario. Stick to what you actually need to launch.

Step 3: Create your first content type

Now, in Contentful:

  1. Go to the “Content model” tab.
  2. Click “Add content type.”
  3. Give it a name (e.g., “Blog Post”). The API Identifier auto-fills, but you can tweak it.
  4. Add a description if you want, but don’t stress over it.

Click “Create” to save.

Naming advice: Use singular names (“Author”, not “Authors”). Keep it short and readable. You’ll be living with these names.

Step 4: Add fields to your content type

Here’s where you define what makes up, say, a Blog Post.

  1. Inside your new content type, click “Add field.”

  2. Choose a field type:

    • Short text: Titles, slugs, simple strings
    • Long text: Body copy, descriptions
    • Media: Images, videos
    • Number: Prices, ratings
    • Boolean: True/false switches
    • Reference: Link to another content type (like “Author”)
    • Date and time: Published date, event times

  3. Set up each field:

    • Name (e.g., “Title”)
    • Help text (optional, but it helps editors)
    • Required or not
    • Validations (e.g., character limits)

Repeat until you’ve added all the fields you need.

What to avoid: - Don’t add a field “just in case.” You can add more later. - Don’t use “Short text” for everything. Pick the right type. - Avoid making everything required—editors will hate you for it.

Step 5: Use references to connect content types

References let you link content types together. For example, a Blog Post can have an Author (which is its own content type).

To set this up: 1. Add a “Reference” field to your content type. 2. Choose which content type(s) it can reference. 3. Decide if it’s a single reference or can link to many (e.g., one author, multiple categories).

Why bother? - Keeps content DRY (don’t repeat yourself) - Makes it easier to update things in one place (change an author’s bio, it updates everywhere)

What doesn’t work well: Don’t try to “hack” references to do things like tagging or categorization unless you really need the flexibility. Sometimes a simple text field or dropdown is better.

Step 6: Configure field settings and validations

Click on each field to set: - Required/optional - Unique values (like for slugs) - Allowed character limits - Help text for editors, so they know what goes where

Pro tip: Use validations to keep your editors honest. If you don’t want 500-character headlines, set a max length.

Step 7: Save and publish your content model

Once you’re happy, hit “Save.” Contentful will ask you to “Publish” the content type. This makes it available for editors and APIs.

  • You can still edit the model later, but some changes (like field types) may be restricted if content already exists.
  • If you realize you messed up, you can delete fields, but you’ll lose any data stored there.

What to ignore: Don’t stress about getting it 100% perfect on the first try. You’ll tweak things as you go.

Step 8: Add more content types as needed

Repeat steps 3-7 for more types (Authors, Categories, Products, whatever else you need).

  • Reference between types as needed.
  • Keep your field names consistent.
  • Don’t copy-paste content types unless you really need two almost-identical things.

Step 9: Organize and update your content model

Once you’ve got a few types, you’ll want to keep things tidy. Here’s how:

  • Reorder fields: Drag fields up or down for better editor experience.
  • Group fields: Use “Field groups” (if available) to organize complex types.
  • Add help text and instructions: Saves you answering the same questions later.
  • Review regularly: As your site/app grows, revisit your content model. Remove fields nobody uses, merge types if it makes sense.

What not to do: Don’t be afraid to refactor, but don’t change models just for the sake of it. Every change can impact your content editors and API consumers.

Step 10: Manage changes safely (and avoid breaking stuff)

Contentful lets you edit models, but not every change is safe after you have real content. Here’s what you can and can’t do:

  • You can:

    • Add new fields
    • Make optional fields required (but be careful—existing content might break)
    • Change help text and validations

  • You can’t (easily):

    • Change field types (e.g., from Text to Reference)
    • Delete required fields with content in them

Best practice: When making big changes, communicate with your team. Test in a sandbox space if possible. And export your content model before big edits—you can always import it back if things go sideways.

Honest takes: What works, what doesn’t, and what to skip

  • What works: Contentful’s UI is generally clean and easy for most teams. References are powerful for relating data.
  • What doesn’t: Over-complicating your model. People get excited and build out huge, abstract models. Don’t. You’ll spend more time explaining it than using it.
  • What to skip: Don’t get sucked into using every feature (like UI extensions or field editors) unless you really need them. Start simple.

Summary: Keep it simple, iterate often

You don’t have to get your content model perfect on day one. Start with what you need, get your team’s feedback, and improve as you go. The goal is to make your content easy to manage and flexible enough for the changes you know are coming (and the ones you don’t). In Contentful, less really is more—so build what you’ll actually use, and don’t be afraid to edit as you learn.

Happy modeling.