Grav Blueprints and Forms: Custom Fields, Email, Leads

Our company is engaged in the development, support and maintenance of sites of any complexity. From simple one-page sites to large-scale cluster systems built on micro services. Experience of developers is confirmed by certificates from vendors.

Development and maintenance of all types of websites:

Informational websites or web applications
Business card websites, landing pages, corporate websites, online catalogs, quizzes, promo websites, blogs, news resources, informational portals, forums, aggregators
E-commerce websites or web applications
Online stores, B2B portals, marketplaces, online exchanges, cashback websites, exchanges, dropshipping platforms, product parsers
Business process management web applications
CRM systems, ERP systems, corporate portals, production management systems, information parsers
Electronic service websites or web applications
Classified ads platforms, online schools, online cinemas, website builders, portals for electronic services, video hosting platforms, thematic portals

These are just some of the technical types of websites we work with, and each of them can have its own specific features and functionality, as well as be customized to meet the specific needs and goals of the client.

Showing 1 of 1All 2062 services
Grav Blueprints and Forms: Custom Fields, Email, Leads
Simple
from 1 day to 3 days
Frequently Asked Questions

Our competencies:

Development stages

Latest works

  • image_website-b2b-advance_0.webp
    B2B ADVANCE company website development
    1365
  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1254
  • image_websites_belfingroup_462_0.webp
    Website development for BELFINGROUP
    961
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1192
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    933
  • image_bitrix-bitrix-24-1c_fixper_448_0.webp
    Website development for FIXPER company
    951

Standard Grav forms often do not cover business requirements: you need image upload fields, complex validation, CRM integration. Editors waste time on manual input, and managers receive incomplete data. We set up Blueprints and Grav forms including custom YAML fields, contact forms with email notifications via SMTP, multi-step forms, and flexible email templates. Over 50 projects on Grav — from simple contact forms to multi-step questionnaires with conditional fields.

For example, for a service company we set up a page with tabs: content, SEO, and settings. Previously editors filled a single text field; now they select custom blocks via filepicker and list. Result — filling time reduced threefold, and input errors dropped by 70%. Average form fill time decreased from 10 to 2 minutes.

What problems we solve

  • Uncomfortable fields in admin. Editors waste time on manual entry of unnecessary fields. Blueprints remove everything extra: we show only needed tabs (content, SEO, settings), add filepicker for images, list for benefits, toggle for show/hide blocks.
  • Lead loss. Without SMTP, emails go to spam or don't arrive. We connect a reliable mail server (Gmail, Yandex, Mailgun), configure DKIM/SPF, and guarantee 99.9% delivery.
  • Single-step form is not enough. For complex orders, multi-step forms with validation at each step are needed. We implement via Form Wizard plugin or custom JS — data is saved even on reload.
  • Complex field validation. Standard field types don't always meet business requirements. We add custom validators in PHP and client-side to reject incorrect data.

How to set up Blueprints for Grav pages?

One deep case: a service page with tabs "Content", "SEO", "Settings". Example file user/blueprints/pages/service-detail.yaml:

title: Service Detail Page
extends@:
    type: default
    context: blueprints://pages

form:
  fields:
    tabs:
      type: tabs
      active: 1
      fields:
        content:
          type: tab
          title: Content
          fields:
            header.intro:
              type: textarea
              label: Introduction
              help: Brief description for preview
              size: large
              rows: 3
            header.hero_image:
              type: filepicker
              label: Main image
              preview_images: true
              folder: '@self'
              accept: ['image/jpeg', 'image/png', 'image/webp']
            header.features:
              type: list
              label: Features
              style: vertical
              fields:
                .icon:
                  type: text
                  label: CSS icon class
                  placeholder: 'icon-check'
                .text:
                  type: text
                  label: Feature text
        seo:
          type: tab
          title: SEO
          fields:
            header.metadata.description:
              type: textarea
              label: Meta Description
              size: large
              rows: 2
              validate:
                max: 160
            header.metadata.keywords:
              type: text
              label: Meta Keywords
            header.canonical:
              type: url
              label: Canonical URL
        options:
          type: tab
          title: Settings
          fields:
            header.show_sidebar:
              type: toggle
              label: Show sidebar
              default: 1
              options:
                1: Yes
                0: No
            header.template:
              type: select
              label: Output template
              options:
                default: Standard
                wide: Wide
                fullscreen: Fullscreen

Blueprint field types and their purpose:

Type Purpose
text Single-line text
textarea Multi-line text
toggle Toggle (bool)
select Dropdown list
checkboxes Multiple selection
filepicker File selection from media
list Repeatable field groups
array Key-value pairs
date Date
url URL with validation
number Numeric field
color Color picker
editor Markdown editor

Contact form and email

Form described in frontmatter of contact.md:

---
title: Contacts
template: form

form:
  name: contact-form
  fields:
    name:
      label: Name
      type: text
      validate:
        required: true
        min: 2
    email:
      label: Email
      type: email
      validate:
        required: true
    phone:
      label: Phone
      type: tel
      placeholder: '+375 XX XXX-XX-XX'
    service:
      label: Service of interest
      type: select
      options:
        web: Website development
        app: Mobile app
        seo: SEO promotion
        other: Other
    message:
      label: Message
      type: textarea
      validate:
        required: true
        min: 20
      rows: 5
    honeypot:
      type: honeypot   # bot protection

  buttons:
    submit:
      type: submit
      value: Send
      classes: btn btn-primary

  process:
    - email:
        from: "{{ form.value.email }}"
        to: [email protected]
        subject: "Site request: {{ form.value.name }}"
        body: "{% include 'forms/email/contact.html.twig' %}"
    - save:
        fileprefix: contact-
        dateformat: Ymd-His-u
        extension: txt
        operation: create
        body: "{% include 'forms/data.txt.twig' %}"
    - message: Thank you! We will contact you within 1 business day.
    - display: /thank-you
---

## Contact us

Leave a request and we will answer within a business day.

Email notification template:

{# user/themes/my-theme/templates/forms/email/contact.html.twig #}
<h2>Новая заявка с сайта</h2>
<table>
    <tr><td><strong>Имя:</strong></td><td>{{ form.value.name }}</td></tr>
    <tr><td><strong>Email:</strong></td><td>{{ form.value.email }}</td></tr>
    <tr><td><strong>Телефон:</strong></td><td>{{ form.value.phone }}</td></tr>
    <tr><td><strong>Услуга:</strong></td><td>{{ form.value.service }}</td></tr>
    <tr><td><strong>Сообщение:</strong></td><td>{{ form.value.message }}</td></tr>
</table>

Email plugin configuration:

# user/config/plugins/email.yaml
enabled: true
mailer:
  engine: smtp
  smtp:
    server: smtp.gmail.com
    port: 587
    encryption: tls
    user: [email protected]
    password: app-specific-password

from: [email protected]
from_name: My Site
to: [email protected]

Why correct email configuration is important?

Without SMTP, emails often land in spam. We configure SPF and DKIM records, use reliable mail services. Result — 99.9% delivery. Emails arrive with correct subject and readable template. Comparison of sending methods:

Method Delivery Complexity
SMTP 99.9% Medium
Sendmail ~70% Low
PHP mail ~50% Low
More about SMTP configuration

To send via SMTP, specify server, port, and credentials. We use only TLS encryption and test delivery with a test email. In case of problems, we set up a backup mail server.

How to implement multi-step form in Grav?

For complex orders or surveys, we use multi-step forms. Example configuration:

form:
  name: multistep-order
  fields:
    step1:
      type: section
      title: Step 1. Contacts
      fields:
        name:
          type: text
          label: Name
        email:
          type: email
          label: Email
    step2:
      type: section
      title: Step 2. Order details
      fields:
        budget:
          type: select
          label: Budget
          options:
            small: up to $1000
            medium: $1000–5000
            large: over $5000
        details:
          type: textarea
          label: Task description

For step-by-step display, custom JS or the form-wizard plugin is required. Each step is a section with fields. Data is saved in session, after last step — submit. We validate at each step: email must be correct, phone in required format. Multi-step forms increase conversion by 40% compared to single-step.

Work process

  1. Audit of current forms and Blueprints — identify bottlenecks, gather editor requirements.
  2. Design field schema — tabs, types, validation.
  3. Implement Blueprints — YAML files for pages and configuration.
  4. Configure form and email — Form plugin, SMTP, email template.
  5. Testing — check all scenarios, sending, validation.
  6. Deploy and training — upload to production, conduct short training for editors.

What's included in the work

  • YAML Blueprint schemas for all needed page types (documentation in code).
  • Contact form with bot protection (honeypot + rate limit).
  • Email template in Twig.
  • SMTP server configuration.
  • Instructions for field editing.
  • Email delivery guarantee (fix if not working).

Timelines and cost

Basic setup — from 2 business days. Complex project (multi-step forms, custom fields, email templates) — 3–5 days. We provide an accurate estimate after briefing. Cost is calculated individually. Budget savings with a comprehensive order reach 25%. Our solutions pay off within the first month.

Common problems and their solution

  • Honeypot is forgotten — form gets flooded with spam.
  • Server-side validation is not checked (only JS) — attackers bypass.
  • Email backup is not configured — on SMTP failure, leads are lost.

We avoid these at the design stage. Contact us — we will evaluate your project in 1 day. Order Grav Blueprints and form setup today. Get a consultation on integration with your CRM.

Without proper configuration, YAML Blueprint schemas may seem complex, but in fact they are a powerful tool for customizing Grav.

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.

CMS Hosting API Best Use Case
Strapi Self-hosted / Cloud REST, GraphQL Startups, customization
Directus Self-hosted / Cloud REST, GraphQL Wrapper for existing DB
Sanity Cloud GROQ, GraphQL Media, complex content
Contentful Cloud REST, GraphQL Enterprise, localization
Drupal Self-hosted JSON:API, GraphQL Government, complex permissions

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:

Project Type Timeline
Simple site on Strapi + Next.js 4–8 weeks
Multilingual corporate site 8–16 weeks
Migration from WordPress to headless +4–8 weeks additional
Drupal enterprise portal 3–6 months

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.