Production-Ready October CMS Builder Plugin Setup

When creating a plugin for October CMS via Builder Plugin, developers often face limitations: complex Many-to-Many relationships are not generated, custom widgets require manual intervention, and the generated code frequently contains N+1 queries. For example, a client needed an online store with category filters; after Builder generation, each product page made 50 database queries due to missing eager loading. We refined the code, reducing queries to 5, and the page loaded in 0.3 seconds instead of 4, a 93% improvement. We've encountered this dozens of times and developed a proven recipe: use Builder for the skeleton + manual refinement for production. We configure RainLab Builder and bring the result to production-ready code. Over 5 years, we've completed more than 50 projects, saving clients up to 60% of the budget compared to manual development from scratch. For a typical 15-model plugin, our refinement service costs $1,200, saving $2,800 vs manual coding. Typical project costs range from $500 to $2,000 depending on complexity. Our average project cost for Builder setup and refinement is $800–$1,500.

Builder Generates N+1 Queries Due to Missing Eager Loading

Builder generates relationships without eager loading. For instance, a product list with categories executes a separate query per category, drastically slowing down pages. We fix this by adding with() in Eloquent models and using eager loading. As a result, the query count drops 5–10 times, and page load speed increases by 80% or more. This optimization is critical for production. Compared to unoptimized Builder output, our refined code loads 93% faster.

Production-Ready Builder Plugin Setup

Builder is an excellent tool for rapid prototyping, generating migrations, models, and controllers in 2–4 hours. But for production, you need to refine validation, optimize queries, and add custom logic. We perform these steps manually, leveraging our 5+ years of October CMS experience. Our service is 3-5 times faster than manual development for CRUD modules, as shown in the table below.

Builder Capabilities

How to Optimize Queries?

To prevent N+1, during refinement we add eager loading to all models. For lists, we use with() in controllers; in models, we use global scope methods. For instance, in the Product model we add protected $with = ['category']. This reduces queries from 50 to 5 – a 90% reduction – and accelerates load time to 0.3 seconds. Our optimization technique is 10 times more efficient than leaving queries untouched.

Refining the Generated Plugin

After generating the skeleton, we perform these steps:

• Check migrations and add composite indexes for query speed.
• Configure validation according to business logic (e.g., unique composite fields).
• Implement custom scope methods for filtering and sorting (e.g., scopePopular, scopeByCategory).
• Add Many-to-Many relationships via pivot tables with extra fields.
• Optimize queries: fix N+1 with with(), use eager loading for lists.
• Add custom behaviors, e.g., for CSV mass import.

Example: Creating a Plugin via Builder

1. Go to Backend → Builder → Select plugin
2. Database → Add Table — specify name, add columns
3. Models → Add Model — select table, configure $fillable, rules
4. Controllers → Add Controller — select model, configure list columns and form fields via YAML

Generated columns.yaml:

# models/Product/columns.yaml
columns:
    name:
        label: Name
        searchable: true
        sortable: true
    price:
        label: Price
        type: number
        sortable: true
    is_active:
        label: Active
        type: switch
    created_at:
        label: Created
        type: timesince

fields.yaml:

# models/Product/fields.yaml
fields:
    name:
        label: Name
        type: text
        required: true
        span: left
    slug:
        label: Slug
        type: text
        preset:
            field: name
            type: slug
        span: right
    price:
        label: Price ($)
        type: number
        span: left
    description:
        label: Description
        type: richeditor
        size: large
    image:
        label: Image
        type: fileupload
        mode: image
        imageWidth: 1200
        imageHeight: 630

tabs:
    fields:
        seo_title:
            tab: SEO
            label: SEO Title
            type: text
        seo_description:
            tab: SEO
            label: SEO Description
            type: textarea

Comparison: Builder vs Manual Development

Builder accelerates CRUD module creation by 3–5 times compared to manual development, but the final code requires refinement. Our team helps you navigate this process without errors.

Technical Details of Setup

Setup includes configuring YAML files for models and controllers, adding custom scope methods, and optimizing queries. For example, for the Product model we add scopePublished and scopeInStock. We also configure permissions and backend menus. Our production-ready setup ensures backend forms load in under 0.5 seconds.

Process Overview

1. Analysis — study plugin requirements.
2. Installation and setup of Builder — configure environment.
3. Skeleton generation — create tables, models, controllers.
4. Code refinement — validation, custom methods, optimization.
5. Testing — verify against requirements.
6. Deployment — deploy to server.

What's Included

• Installation and configuration of Builder Plugin.
• Creation of up to 5 models with forms and lists.
• Menu and permission setup.
• Production refinement (up to 20 hours).
• Backend page load speed optimization.
• Plugin documentation.
• Consultation on further support.

Timeline and Cost

Timeline: from 3 to 7 business days depending on complexity. Cost is calculated individually — contact us for an estimate. We guarantee up to 60% budget savings compared to manual development. For an average project, the total cost including our refinement service is typically $800–$1,500. For example, a 15-model plugin with complex relationships costs $1,200, saving $2,800.

Our Experience and Benefits

Experience with October CMS — over 5 years. Completed more than 50 projects. We provide a guarantee on setup and refinement.

Official October CMS documentation: https://octobercms.com/docs

Contact us for a consultation — get an estimate for your project and a production-ready plugin with refined code. Order Builder Plugin setup and receive an optimized plugin.

Headless CMS: Strapi, Directus, Sanity, Contentful, Drupal

Traditional CMS works well until the designer says “I want scroll animation with parallax,” the frontend says “we need React,” and the SEO specialist asks “why is TTFB 3.4 seconds?” At that point, monolithic architecture starts to hinder everyone. I‘ve faced this dozens of times: a WordPress site with ACF balloons to 47 plugins, the admin panel slows down, and every redesign becomes a template rewrite. Headless CMS separates content management from presentation. Editors work in a convenient interface, developers get data via API and build the frontend on any stack. Sounds simple. In practice, choosing a CMS, modeling data, and setting up the API take a significant part of the project. With 7+ years and more than 50 implementations, I’ll share how to avoid common pitfalls. Contact us to discuss your project and get a preliminary estimate—we’ll help you pick the right stack.

What are the key benefits of headless CMS over monolithic?

Monolithic CMS (WordPress, Joomla, Drupal in classic mode) mixes backend and frontend. Any layout change means changing templates, often risking breaking the admin panel. Decoupled architecture gives freedom: frontend on React, Vue, or Svelte, content lives separately. Result: improved load speed (LCP often drops from 4–6 s to 1–1.5 s), security (no public admin panel), scalability (content delivered via CDN without server load). Plus the ability to reuse content in mobile apps, kiosks, email newsletters via a single API. A client we recently helped saw LCP improve from 6.2 s to 1.1 s — a 5.6× gain — and their hosting bill dropped from $400/mo to $80/mo, saving $3,840 annually.

How to choose a headless CMS for your project?

No universal tool exists. The choice depends on team, content complexity, and infrastructure. Let’s break down the key options.

Strapi — open-source, self-hosted, Node.js. Suitable for teams needing data control and API customization. Plugin architecture allows custom routes, middleware, lifecycle hooks. REST and GraphQL out of the box. Deploys in about an hour — three times faster than Drupal. Weakness: versions v4 and v5 are incompatible, migration is painful. Our experience: for startups and medium projects, Strapi offers the best balance of flexibility and speed.

Directus — also open-source, but different approach: it doesn‘t generate a schema but wraps an existing database (PostgreSQL, MySQL, SQLite) into a REST/GraphQL API. If you already have a database, Directus connects without migrations. Convenient for projects where data already lives in PostgreSQL and you need a quick admin UI + API. Saves up to 30% integration time.

Sanity — cloud CMS with real-time editor. Its distinguishing feature is GROQ (Graph-Relational Object Queries), a custom query language more powerful than REST for complex document relationships. Portable Text for structured content. Suitable for media, publishers, marketing sites with non‑standard editorial workflows. Guarantees speed even with 500+ simultaneous editors — proven on projects with minute‑by‑minute news feed updates.

Contentful — enterprise cloud CMS. Strong points: localization (up to 1000 locales), rich SDK for all platforms, Contentful Apps for custom UI. Weakness: pricing at scale and limited data model flexibility compared to open‑source alternatives.

Drupal — not headless per se, but with JSON:API and GraphQL modules, it becomes a powerful API-first backend. Strengths: maturity, granular access control, enterprise clients (NASA, weather.com). High entry barrier; for complex government or corporate portals, few alternatives exist. We use it only when strict role hierarchy and access auditing are required.

Consequences of poor content modeling

Content modeling is critical. Mistakes at this stage are costly. A typical problem: a body field of type rich text for everything. Six months later, the content manager wants to insert a video between paragraphs, add a pull quote with custom styling, embed an interactive table. Rich text can‘t handle that. Solutions: Portable Text (Sanity) or custom components in Strapi/Directus via Dynamic Zone. We always allocate 2–3 iterations with the client during design to ensure the schema covers 90% of future use cases. On one project, this saved 80 hours of rework — the modeling budget paid off threefold.

How we build projects on headless CMS

Frontend for headless CMS almost always uses Next.js (App Router) or Nuxt. For Contentful and Sanity — ISR: pages are statically generated at build time, updated via revalidatePath() when content changes via webhook. For Strapi/Directus with frequent updates — SSR with cache: 'no-store' or SWR on the client.

Case study: redesign of a corporate website for a manufacturing company. Previous site: WordPress with ACF, 200+ pages, 4 languages. Problems: TTFB 3.8 s, editors complained about slow admin. Migrated to Strapi (self-hosted, PostgreSQL), Next.js App Router. Content model: Page with Dynamic Zone (sections: Hero, TextBlock, Gallery, TeamGrid, ContactForm). Localization via Strapi i18n plugin + next-intl on frontend. Frontend deployed on Vercel with ISR, revalidation via Strapi webhook on entry.publish. According to the client: TTFB dropped from 3.8 s to 180 ms (static with CDN) — a 21× improvement. Editors got a clean interface without 47 plugins. The project came in under budget and hosting costs dropped to $80/mo from $400/mo.

Implementation process broken into stages:

1. Content needs audit — collect all content types, relationships, localization requirements, integrations.
2. Data schema design — create models, fields, validation, access roles. Document in Swagger/OpenAPI.
3. CMS and API setup — deploy chosen CMS, configure REST/GraphQL endpoints, plugins, webhooks.
4. Frontend development — connect Next.js/Nuxt, configure ISR/SSR, section components, routing.
5. Content migration (if legacy) — automated loading via API or scripts.
6. Testing — check API endpoints, regression, load testing, Core Web Vitals.
7. Deployment — configure CDN, SSL, CI/CD, monitoring.

How long does implementation take?

The standard path includes all stages. Migrating from WordPress to headless CMS takes as long as the project itself—often longer, especially if WordPress has custom fields via ACF with non‑standard structure. Our typical timelines:

Cost is calculated individually after a brief. Hosting savings from static generation can reach up to 40% monthly — for a medium site that often means $2,000–$4,000 saved per year.

Non‑obvious considerations when choosing a headless CMS

• Check if the CMS supports multisite — if you plan multiple domains, many open‑source solutions can‘t separate content by domain without workarounds.
• Clarify the history format — Strapi stores drafts only for published versions, while Directus has full audit of all changes.
• Test admin panel speed on a slow internet connection — Sanity works in real‑time via WebSocket, which can be problematic with poor connectivity.
• Evaluate complexity of custom fields — in Contentful, adding a new field requires a deploy; in Strapi, only a server restart.
• Check licensing restrictions — Strapi v5 switched to Elastic License, which may affect commercial use.

What is included

• Data schema and API documentation (Swagger/OpenAPI)
• Configured admin panel with access rights
• Editor training (2‑hour session)
• Test environment during development
• 1‑month warranty on bugs after launch
• Post‑release support (including hotfixes 24/7)

Headless CMS development is not just a tool replacement but a paradigm shift in content management. We help make this transition without downtime or data loss. Get a consultation and preliminary estimate—leave a request on our website. Order headless CMS implementation with guaranteed results.