Craft Laravel Package

Technical Evaluation

Architecture fit. craftcms/craft is a Composer project package (type: project), not a library. It is the starter skeleton — front controller, Yii2 bootstrap, .env handling, config scaffolding — for a standalone Craft CMS install. It cannot be composer required into an existing Laravel application; doing so would introduce a second framework runtime, a second service container, and a competing bootstrapping path within the same process. Any realistic "Laravel leverage" is therefore at the HTTP boundary, not inside PHP: Laravel consumes Craft as a headless content service via GraphQL (Craft Pro), the Element API plugin, or a thin custom module exposing JSON.

Integration feasibility. Feasible and well-trodden, but only in the headless/BFF pattern. Craft ships first-party GraphQL with a schema you define against your content model, and its element/query APIs map cleanly to typed content contracts. Authentication, sessions, routing, and business logic stay in Laravel; Craft owns editorial content, assets, and localization. The coupling cost is a network hop and a second deploy target — acceptable for content delivery, unacceptable if the team expects a single monolithic Laravel app.

Technical risk.

• Framework divergence (high). Yii2 vs. Laravel — separate DI, config, queue, migrations, and caching. Custom Craft modules/plugins require Yii2 fluency, which is scarce relative to Laravel talent.
• Licensing shock (medium). The starter is 0BSD, but GraphQL requires Craft Pro (~$99/yr Solo is free but feature-limited; Pro and Enterprise are paid). Budgeting must be explicit at the TPM level or a headless plan silently fails at launch.
• Two upgrade streams (medium). Craft 4→5 required real project-config work; Laravel 11→12 similarly. These will not align.
• Plugin quality variance (medium). The Craft plugin store is smaller than Packagist and uneven in maintenance.
• Low signal score (contextual). The package's opportunity score of 1.14 and 206 stars reflect that it is thin scaffolding, not a strategic asset — the real dependency is craftcms/cms. Do not over-index on this repo's metrics when sizing the bet.

Key questions.

1. Is the requirement editorial content modeling or full site delivery? Only the former justifies a second stack.
2. Who owns the content schema, and will it live in git as project config?
3. Is a Pro license (GraphQL) approved, or are we confined to Element API/custom controllers?
4. Does Craft's PHP 8.2+ / MySQL 8+ requirement align with the Laravel app's runtime and DB versions?
5. Is there an existing Yii2/Craft skill on the team, or is this a net-new competency?

Integration Approach

Stack fit. Craft runs on PHP 8.2+, MySQL 8+/PostgreSQL, Composer 2 — technically compatible with a typical Laravel host, but it should be deployed as a separate service with its own database, its own release pipeline, and its own .env. Shared hosting of both apps behind one vhost is possible but conflates failure domains and should be rejected for anything beyond a prototype.

Migration path.

1. Boundary decision — headless Craft behind GraphQL, consumed by Laravel as a BFF. Laravel remains the system of record for users, commerce, and app state.
2. Content export — pull existing content (WordPress/WYSIWYG/Laravel tables) into a normalized form; map to Craft sections, entry types, matrix fields, and asset volumes. Model in project config, not the control panel, so it is diffable and reviewable.
3. Consumer build — Laravel-side repository classes with typed DTOs, a Redis cache keyed on Craft's element dateUpdated/cacheTags, and a stale-while-revalidate pattern so editorial latency never hits end users.
4. Cutover — path-by-path with redirect rules held in Laravel, not Craft, so rollback is a routing change.

Compatibility. Keep authentication entirely in Laravel. Do not attempt to share a database, share a user table, or bridge sessions between Yii and Laravel — cross-framework session sharing is the single most common source of pain in this pattern. Use signed JWTs or a server-to-server key if Craft preview needs to authenticate editors. Pin Craft and Laravel PHP minor versions independently; they will drift.

Sequencing (roughly 6–10 weeks for a headless pilot).

• Week 1–2: headless spike — one section, GraphQL read query, Laravel consumer with cache.
• Week 3–4: content model in project config; editorial pilot with two sections and one editor.
• Week 5–6: asset pipeline, image transforms, localization if in scope; license procurement.
• Week 7–8: Laravel BFF hardening, cache invalidation on publish webhook, observability.
• Week 9–10: phased cutover with redirects and a documented rollback.

Operational Impact

Maintenance. Two Composer dependency trees, two CVE streams, two CI pipelines. The starter project itself needs almost no upkeep, but craftcms/cms and its plugins do — plan for a quarterly Craft patch window and a major-version upgrade every ~18–24 months. Project config drift between environments is the recurring operational tax; enforce project-config/apply in deploy and diff it in CI.

Support. Craft is commercially backed with responsive first-party support on paid tiers, an active Discord, and StackExchange coverage. That is genuinely better than most OSS CMS support — but it does not overlap with the Laravel ecosystem, so the on-call rotation now spans two worlds. Plugin support is vendor-dependent and should be vetted before adoption.

Scaling. Craft scales the same way Laravel does — horizontal PHP-FPM behind a load balancer, DB read replicas, Redis for cache and queues. Headless adds a GraphQL complexity budget requirement: cap query depth and complexity per API key, or a single expensive query becomes a Laravel-side outage. Image transforms are CPU-heavy and should run on a dedicated queue worker, not the web tier. For a content site, this is comfortably sufficient; the constraint is cache invalidation strategy, not raw throughput.

Failure modes to instrument for.

• Project config drift → deploy fails or schema diverges silently. Mitigate with CI diff gates.
• License/edition mismatch → GraphQL returns 403 in production after working locally. Gate this in a pre-deploy health check.
• Cross-site CORS/cookie misconfiguration in headless preview — bites every team once.
• Queue backlog on asset transforms, stalling publishing.
• Plugin abandonment — pin versions, avoid single-maintainer plugins for critical paths.
• GraphQL query cost explosion under editorial experimentation.

Ramp-up. Editors: days — Craft's control panel is best-in-class and is the strongest argument for this package. Laravel developers: a week to author content models and GraphQL queries confidently; two to four weeks to be productive writing custom Craft modules/plugins in Yii2, which is the real hidden cost. If the roadmap includes significant Craft-side customization, budget for a Craft specialist or accept a slower first quarter. Given the low opportunity signal on this specific package, treat Craft as a commodity CMS choice — justified by editorial UX, not by technical differentiation.