# Justin Holt - Official Craft CMS Partner

> Full-stack Craft CMS developer and Official Craft CMS Partner based in Charlotte, NC. 27+ years of web development experience. Specializing in custom Craft CMS development, Commerce, headless APIs, multi-site architecture, DevOps, and AI-powered workflows. 70+ clients served across real estate, fintech, entertainment, food, nonprofits, government, education, and manufacturing.

## About Justin Holt

Justin Holt is an independent web developer operating as justinholt.com, incorporated. He is an Official Craft CMS Partner, recognized by Pixel & Tonic (the makers of Craft CMS) for deep expertise in the platform. His work spans custom plugin and module development, Craft Commerce storefronts, headless API builds using Element API, multi-site installations with multi-language support, performance optimization, deployment pipeline setup, and AI-powered CMS integrations.

He works both directly with clients and as a second-seat developer embedded with agency teams, providing Craft CMS expertise to augment existing development capacity.

### Contact

- Website: https://justinholt.com
- Email: justin@justinholt.com
- Phone: +1 (704) 369-4557
- Craft Partner Profile: https://craftcms.com/partners/justinholtcom-incorporated
- Twitter/X: @justinholtweb
- AI Developer: https://ai-developer.io
- Location: Charlotte, North Carolina, USA

## Services

### Custom Craft CMS Development
Custom plugins, modules, and integrations built to extend Craft CMS beyond its core capabilities. Twig templating, PHP/Yii back-end development, and full-stack Craft builds.

### Craft Commerce
E-commerce builds on Craft Commerce including storefronts, payment gateway integrations (Stripe, PayPal), product configurators, and custom order workflows.

### Second Seat Developer
Team augmentation for agencies. Embeds alongside existing development teams as a force multiplier, bringing deep Craft expertise to accelerate timelines and strengthen capacity.

### Frontend Development
Modern front-end builds using Vite, Tailwind CSS, and vanilla JavaScript. Performance-focused with attention to Core Web Vitals, accessibility, and responsive design.

### DevOps and ServerOps
Deployment pipelines (GitHub Actions, Laravel Forge), server configuration, load balancing, Redis caching, SSL management, and infrastructure monitoring.

### AI Agent Integration
AI-powered CMS workflows including automated image alt text generation, meta description generation, AI-enhanced site search, content freshness auditing, and auto-tagging systems. Integrations with OpenAI and Anthropic Claude APIs.

## Technical Expertise

### Primary Stack
- Craft CMS 4 and 5 (Official Partner)
- PHP 8.2+, Yii 2 framework
- Twig template engine
- Craft Commerce
- MySQL, PostgreSQL

### Front-End
- Vite (build tool)
- Tailwind CSS
- Vanilla JavaScript
- InstantSearch.js (Algolia)
- Responsive and accessible HTML/CSS

### Search
- Algolia (with Scout plugin for Craft)
- InstantSearch.js for faceted search UIs
- Craft's built-in search with eager loading optimization

### DevOps
- Git, GitHub, GitHub Actions
- Laravel Forge
- DDEV (local development)
- Docker
- Redis
- Nginx
- Load balancing

### AI and Automation
- OpenAI API (GPT-4o, GPT-4o-mini)
- Anthropic Claude API (Claude Haiku, Sonnet, Opus)
- AI-powered content workflows in Craft CMS
- Queue-based async AI processing

### Craft CMS Plugins Regularly Used
- SEOmatic (nystudio107) - SEO management
- Retour (nystudio107) - Redirect and 404 management
- Vite (nystudio107) - Vite build tool integration
- Imager X (spacecraftio) - Image transforms and optimization
- Blitz (putyourlightson) - Static page caching
- Formie (verbb) - Form builder
- Navigation (verbb) - Navigation management
- Sprig (putyourlightson) - Reactive Twig components
- Scout (rias) - Algolia search indexing
- CKEditor (craftcms) - Rich text editing
- Craft Commerce (craftcms) - E-commerce

## Blog Content

Practical articles on Craft CMS development, modern tooling, and real-world implementation patterns.

### Building Faceted Search in Craft CMS with Algolia and InstantSearch
URL: https://justinholt.com/blog/algolia-instantsearch-craft-cms/
Topics: Algolia, InstantSearch.js, Scout plugin, faceted filtering, real estate property search
Summary: How to build fast, faceted search and listing pages in Craft CMS using Algolia and InstantSearch.js. Covers indexing entries with the Scout plugin, configuring Algolia searchable attributes and facets, building the InstantSearch front end with refinement lists, range sliders, and result cards. Includes multi-site handling patterns and performance considerations from a real property listings project.

### Multi-Site Architecture in Craft CMS: Patterns That Actually Work
URL: https://justinholt.com/blog/craft-cms-multi-site-architecture/
Topics: Multi-site, multi-language, content propagation, regional sites, multi-brand
Summary: How to architect multi-site and multi-language Craft CMS installations. Covers three patterns: multi-language (same content translated), regional (shared structure, different content), and multi-brand (different sites sharing one backend). Includes template organization, language switcher code, propagation strategies, and common mistakes.

### The Craft CMS Plugins I Install on Every Project (And a Few I Don't)
URL: https://justinholt.com/blog/essential-craft-cms-plugins/
Topics: Plugins, SEOmatic, Formie, Imager X, Blitz, Commerce, Sprig
Summary: An opinionated guide to the best Craft CMS plugins organized by use case, based on 70+ client projects. Covers the "every project" stack (SEOmatic, Retour, Vite, Imager X, Blitz), the "when you need it" stack (Formie, Navigation, Commerce, Sprig, CKEditor), plugins no longer used, and a 5-point evaluation framework.

### What I've Learned as an Official Craft CMS Partner
URL: https://justinholt.com/blog/lessons-official-craft-cms-partner/
Topics: Craft CMS Partner Program, business, freelancing, credibility
Summary: Reflections on being an Official Craft CMS Partner. Covers what the program is, how it changed the business (referral traffic, credibility, access to the Craft team, community), what nobody tells you (profile maintenance, it doesn't replace marketing, specialization matters), and advice for developers considering applying.

### Practical AI Integrations for Craft CMS
URL: https://justinholt.com/blog/ai-integrations-craft-cms/
Topics: AI, OpenAI, Anthropic Claude, content automation, image alt text, search enhancement
Summary: How to integrate AI into Craft CMS workflows with five production-ready examples: auto-generating image alt text with vision models, meta description generation, AI-enhanced site search with query expansion, content freshness checking via cron, and auto-tagging entries. Includes architecture considerations for async queue processing, API cost management, and graceful fallbacks.

### Why I Recommend Craft CMS Over WordPress (And When I Don't)
URL: https://justinholt.com/blog/why-craft-cms-over-wordpress/
Topics: Craft CMS vs WordPress, CMS comparison, content modeling, security
Summary: An honest comparison of Craft CMS and WordPress from someone who built with both for 20+ years. Where Craft wins (content modeling, authoring experience, security, developer experience, multi-site). Where WordPress still wins (ecosystem size, cost of entry, finding developers, blogging). Includes a decision framework for choosing between them.

### Setting Up DDEV for Craft CMS Local Development
URL: https://justinholt.com/blog/ddev-craft-cms-local-development/
Topics: DDEV, Docker, local development, Xdebug, Vite integration
Summary: Complete guide to running Craft CMS locally with DDEV. Covers installation on Mac/Windows/Linux, new project setup, existing project cloning, config.yaml configuration, daily commands, database management, Vite integration with port exposure, Xdebug setup for PhpStorm and VS Code, multiple project management, email testing with Mailpit, and custom DDEV commands.

### Deployment Pipelines for Craft CMS: From Git Push to Production
URL: https://justinholt.com/blog/craft-cms-deployment-pipelines/
Topics: CI/CD, GitHub Actions, Laravel Forge, Project Config, deployment
Summary: How to set up automated deployment pipelines for Craft CMS. Covers Project Config (what it is and why it matters), three deployment approaches (Forge deploy script, GitHub Actions + Forge, GitHub Actions + rsync), post-deploy commands, database backups, environment variables, staging environments, and common gotchas including Project Config conflicts and failed migrations.

### Craft CMS for WordPress Developers: A Translation Guide
URL: https://justinholt.com/blog/craft-cms-for-wordpress-developers/
Topics: WordPress migration, Twig vs PHP templates, ACF vs Craft fields, concept mapping
Summary: A side-by-side guide for WordPress developers learning Craft CMS. Maps WP concepts to Craft equivalents (posts to entries, ACF to built-in fields, themes to templates, WP_Query to element queries). Compares template code, custom fields, and template includes. Covers routing differences, what WordPress does that Craft doesn't, what Craft does better, local development with DDEV, plugin management via Composer, and the learning curve.

### Performance Tuning Craft CMS: Eager Loading, Caching, and Query Optimization
URL: https://justinholt.com/blog/craft-cms-performance-tuning/
Topics: Performance, N+1 queries, eager loading, template caching, Blitz, profiling
Summary: How to make Craft CMS fast. Explains the N+1 query problem with before/after code examples, eager loading with nested relations and image transforms, template caching strategies, static caching with Blitz, query optimization tips (.select(), .one() vs .all(), .exists() vs .count()), and profiling tools (debug toolbar, Yii debug module, query logging). Includes a quick wins checklist.

### Headless Craft CMS: GraphQL vs Element API vs Just Using Twig
URL: https://justinholt.com/blog/headless-craft-cms-graphql-element-api/
Topics: Headless CMS, GraphQL, Element API, REST, Twig, hybrid architecture
Summary: A practical comparison of three ways to get content out of Craft CMS. Covers Twig templates (when and why they're still the best choice), Craft's built-in GraphQL API (setup, queries, image transforms, Matrix field complexity), and Element API (REST-style JSON endpoints). Discusses the hybrid approach, Live Preview considerations, and a decision framework based on multi-platform needs, team expertise, and budget.

### Building Custom Modules in Craft CMS (And When to Skip the Plugin)
URL: https://justinholt.com/blog/craft-cms-custom-modules/
Topics: Custom modules, Yii 2, event listeners, Twig extensions, console commands, queue jobs
Summary: How to build custom modules in Craft CMS for project-specific logic. Includes a module vs plugin decision flowchart, scaffolding with php craft make module, and four practical examples: auto-generating slugs from multiple fields, creating a custom Twig readingTime filter, building a console command for cleaning stale drafts, and syncing entries to an external API with service classes and Craft's queue system.

### Migrating from Craft 4 to Craft 5: What I Learned the Hard Way
URL: https://justinholt.com/blog/craft-4-to-5-migration/
Topics: Craft 5 migration, entry types refactor, Twig changes, plugin compatibility
Summary: A practical guide to migrating Craft CMS from version 4 to 5 based on migrating a dozen sites. Covers the major changes (entry type refactor, content model changes, PHP 8.2+ requirement, Twig updates, plugin ecosystem, Project Config). Includes a pre-migration checklist, step-by-step process (Composer update, running migrations, reviewing Project Config, updating Twig templates, updating custom modules), and common gotchas with before/after code examples.

### Setting Up Vite with Craft CMS
URL: https://justinholt.com/blog/craft-cms-vite-integration/
Topics: Vite, build tools, HMR, Twig integration, nystudio107/craft-vite
Summary: How to set up Vite as the front-end build tool in a Craft CMS project. Covers installing Vite and the craft-vite plugin, project structure, Vite config, Craft plugin config, entry files, wiring it up in Twig with craft.vite.script(), npm scripts, running in development and production, and common gotchas (HMR behind Docker/DDEV, assets not loading in production, font and image resolution).

## Frequently Asked Questions

### What is Craft CMS?
Craft CMS is a flexible, developer-focused content management system built on PHP and the Yii 2 framework. It uses Twig for templating and offers first-class content modeling, multi-site support, a GraphQL API (Pro), and a plugin ecosystem managed through Composer. It's built by Pixel & Tonic.

### Why choose Craft CMS over WordPress?
Craft CMS excels at structured content modeling (built-in custom fields without plugins), offers a cleaner authoring experience with Live Preview, has stronger security posture, uses modern developer tooling (Composer, Twig, proper MVC architecture), and handles multi-site/multi-language natively. WordPress is better for budget-constrained projects, simple blogs, and situations where access to a large developer pool matters.

### What is an Official Craft CMS Partner?
An Official Craft CMS Partner is a developer or agency vetted by Pixel & Tonic (the company behind Craft CMS) for demonstrated expertise in building with Craft. Partners are listed in the Craft CMS partner directory and receive referral leads, early access to beta releases, and closer access to the Craft team.

### How does Algolia work with Craft CMS?
Algolia integrates with Craft CMS through the Scout plugin, which automatically syncs Craft entries to Algolia's search index whenever content is saved, updated, or deleted. On the front end, InstantSearch.js provides pre-built widgets for search boxes, faceted filters, and result displays that query Algolia directly from the browser without hitting the Craft server.

### What is Element API in Craft CMS?
Element API is a first-party Craft CMS plugin by Pixel & Tonic that lets you define REST-style JSON endpoints using PHP config files. You control the exact shape of the JSON response using transformer functions. It's a simpler alternative to GraphQL for serving JSON data to JavaScript components, mobile apps, or third-party integrations.