Documentation

SleekCMS Overview

SleekCMS is a headless content management system with an integrated static site builder. You define structured content models, create and manage content through a visual editor, and either consume that content via API or publish it as a fully built static site — no Git repositories, no build pipelines, no servers to manage.

This page introduces the architecture, core concepts, and use cases that shape how you work with SleekCMS.

What is SleekCMS?

SleekCMS combines two capabilities that are typically separate:

A headless CMS — You model structured content (pages, blog posts, authors, settings) and access it through delivery APIs (REST and GraphQL). Your frontend applications fetch content at build time or runtime, just like any other headless CMS.

A static site builder — You design view templates in an integrated coding environment, and SleekCMS compiles your content and templates into a static site deployed to a global CDN. There is no external build step. You don't push code to a repository or configure a CI/CD pipeline; the platform handles generation and deployment end to end.

You can use either capability independently or both together. Build a marketing site entirely within SleekCMS, power a React or Next.js app through the content API, or do both from the same content models.

How it differs from traditional CMSs

Traditional monolithic CMSs (WordPress, Drupal) couple content storage with presentation. Your content lives inside themes and page templates, making it difficult to reuse across channels.

Headless CMSs solve the coupling problem but typically require you to set up your own frontend, build tooling, and hosting. SleekCMS gives you that headless flexibility while also providing an optional, zero-config site builder for teams that don't want to maintain a separate frontend stack.

Capability Traditional CMS Headless CMS SleekCMS
Structured content modeling Limited Yes Yes
Content API (REST/GraphQL) Requires plugins Yes Yes
Built-in site rendering Yes (coupled) No Yes (decoupled)
No-code publishing Yes No Yes
Multi-channel delivery Difficult Yes Yes

Who it is for

  • Developers who want structured content APIs with TypeScript-friendly schemas, and optionally a built-in rendering layer they don't have to maintain.
  • Content teams who need a clean editing experience with visual page building, draft workflows, and no dependency on engineering for publishing.
  • Agencies managing multiple client sites from a single organization, with reusable content models and isolated environments.

Core Use Cases

Marketing websites — Build landing pages, product pages, and campaign microsites using block-based layouts. Content editors assemble pages visually while developers define the available building blocks.

Blogs and editorial publishing — Model authors, categories, and posts as structured content. Use page collections with slug-based routing for automatic URL generation. Publish through draft-to-published workflows.

Landing page builders — Define a library of section blocks (hero, features, testimonials, pricing) and let editors compose pages without developer involvement. Dynamic blocks give editors layout flexibility within guardrails you control.

Multi-brand and multi-site setups — Manage multiple sites under one organization. Share content models across sites or keep them isolated. Each site gets its own content, templates, and deployment.

Design systems and reusable components — Model UI components as blocks with typed fields. Reference the same block across multiple page models. Changes to a block's structure propagate everywhere it's used.

Structured content APIs for apps — Use SleekCMS purely as a headless backend. Fetch content through REST or GraphQL delivery APIs for mobile apps, SPAs, digital signage, or any frontend that consumes JSON.

Key Concepts

SleekCMS organizes content around four primitives. Understanding these is essential before you start modeling.

Models

A model is a schema definition. It declares the fields, structure, and behavior of a content type. You create models in the admin UI, and each model produces a corresponding content editing interface and API shape.

There are three kinds of models: page models, entry models, and block models.

Pages

A page represents a routable piece of content — something with a URL. Page models define the fields and layout structure for pages.

Pages come in two forms:

  • Static pages — A single instance tied to a fixed path (e.g., /about, /contact). You define the path in the model.
  • Page collections — Multiple instances generated from a slug field (e.g., /blog/my-first-post). SleekCMS generates routes automatically based on the slug.

Pages can contain dynamic block fields, which let editors compose the page layout from a set of allowed block types.

Entries

An entry is a piece of structured content that is not directly routable. Entries don't have URLs on their own — they exist to be referenced by pages or other entries.

Common examples include authors, categories, site-wide settings, and any reusable data that multiple pages might share. You reference entries through relational fields (one-to-one or one-to-many).

Entries can also be configured as admin-only, making them useful for global settings like navigation menus, footer content, or feature flags that editors shouldn't duplicate across pages.

Blocks

A block is a reusable, composable content component. Blocks define a structured set of fields that represent a visual section or UI element — a hero banner, a call-to-action card, a testimonial carousel.

Blocks differ from entries in two important ways:

  • Blocks are embedded inline within pages or other content. They don't exist independently in a content list.
  • Blocks are designed for visual composition. Editors add, remove, reorder, and hide blocks within a page's dynamic block field.

Blocks can be nested inside other blocks, enabling complex but governed layouts.

How they relate

The content architecture follows a clear hierarchy:

Page Model
├── Fields (title, metadata, SEO)
├── Reference Fields → Entry Models (author, category)
└── Dynamic Block Field
    ├── Hero Block
    │   └── Fields (heading, image, CTA)
    ├── Features Block
    │   └── Fields (items collection, layout)
    └── Testimonials Block
        └── Fields (quotes, author references → Entry)

A page is the top-level routable container. It references entries for shared data and contains blocks for composable layout sections. Models define the schema for all three.

What's Next

  • Getting Started — Create your first project, set up models, and publish a page.
  • Content Modeling — Deep dive into pages, entries, blocks, fields, and how to design your content architecture.
  • Site Builder — Learn the integrated coding environment, view templates, and deployment.
  • Content API — REST and GraphQL endpoints for headless consumption.