Core Laravel Package

Product Decisions This Supports

• API-First Strategy: Accelerate development of hypermedia-driven REST and GraphQL APIs with minimal boilerplate, reducing time-to-market for new products or features.
• Build vs. Buy: Buy for teams needing standardized API development with built-in support for JSON-LD, Hydra, OpenAPI, JSON:API, and HAL—avoiding custom integration costs.
• Roadmap Priorities:
  • Multi-format APIs: Support for GraphQL alongside REST in a single codebase, enabling flexible client integrations.
  • Performance Optimization: Leverage caching, pagination, and filtering (e.g., nested relations, UUID filters) to reduce backend load for high-traffic APIs.
  • Developer Experience: Reduce cognitive load with auto-generated documentation (OpenAPI/Swagger, ReDoc) and scaffolding tools (e.g., api-platform generate:bundle).
  • Extensibility: Customize serialization, validation, and security without reinventing core logic (e.g., decorators, DTOs, or middleware).
• Use Cases:
  • B2B/B2C Platforms: Expose domain models (e.g., orders, users) as APIs with HATEOAS for self-descriptive endpoints.
  • Microservices: Standardize API contracts across services using OpenAPI and GraphQL Federation.
  • Legacy Modernization: Wrap existing databases (Doctrine ORM/ODM) in auto-generated CRUD APIs with minimal effort.
  • Headless CMS: Serve content (e.g., articles, products) via JSON:API or GraphQL with dynamic filtering/sorting.

When to Consider This Package

Adopt When:

• Your team prioritizes developer velocity over custom API frameworks (e.g., NestJS, FastAPI).
• You need multi-format APIs (REST + GraphQL) from a single codebase without context-switching.
• Your API requires standardized hypermedia (Hydra, JSON-LD) for machine-readable contracts (e.g., for AI agents or IoT devices).
• You’re using Symfony or Laravel and want to avoid reinventing API infrastructure (auth, validation, pagination).
• Your use case demands fine-grained filtering (nested relations, UUIDs, partial searches) or complex serialization (DTOs, custom formats).
• You need auto-generated OpenAPI/Swagger docs to reduce manual documentation maintenance.

Look Elsewhere If:

• You require non-PHP backends (e.g., Node.js, Go, Rust).
• Your API is stateful (e.g., WebSockets, real-time updates) beyond REST/GraphQL—consider Mercure or Laravel Echo as supplements.
• You need low-level control over HTTP protocols (e.g., custom WebTransport) or non-HTTP APIs (e.g., gRPC).
• Your team lacks PHP/Symfony/Laravel expertise—steep learning curve for advanced customizations (e.g., decorators, metadata providers).
• You’re building a serverless or edge-compatible API (e.g., Cloudflare Workers)—consider Tauri or Bun alternatives.
• Your primary use case is high-frequency trading or ultra-low-latency APIs (e.g., <1ms)—this package adds abstraction overhead.

How to Pitch It (Stakeholders)

For Executives:

"API Platform Core lets us ship APIs 10x faster with 50% fewer engineers.

• Reduce tech debt: Auto-generate REST + GraphQL APIs from your domain models—no manual endpoint coding.
• Future-proof integrations: Support Hydra, JSON-LD, and OpenAPI out-of-the-box for AI, IoT, and partner ecosystems.
• Cut documentation costs: Self-describing APIs with auto-generated Swagger/ReDoc reduce manual API spec maintenance by 70%.
• Scale effortlessly: Built-in pagination, filtering, and caching handle 10M+ requests without custom infrastructure. Example: Our e-commerce team launched a GraphQL + REST product catalog in 2 weeks—replacing a 6-month custom API project. ROI: $250K/year in dev productivity + $100K in reduced API integration errors."

For Engineering Leaders:

"API Platform Core is the ‘React for APIs’—standardized, extensible, and battle-tested.

• Unified API layer: One codebase for REST, GraphQL, and Hydra—no context-switching between frameworks.
• Symfony/Laravel native: Integrates seamlessly with Doctrine, Eloquent, and Symfony’s DI—no vendor lock-in.
• Performance: OPcache, serializer groups, and lazy-loading optimize payloads for high-throughput APIs.
• Extensibility: Customize serialization, validation, and security via decorators, DTOs, or middleware (e.g., add OAuth2 with api_platform/security).
• Tooling: CLI generators, PHPStan rules, and Behat tests accelerate onboarding. Key metrics:
• 90% less boilerplate vs. manual API development.
• 3x faster than custom Express/NestJS APIs for PHP teams.
• Used by Malt, LesFurets, and Societe Generale. Trade-off: Steeper learning curve for advanced metadata customization (e.g., Hydra vocabularies) but payoff is immediate for 80% of use cases."

For Developers:

"Build APIs in PHP without the pain—here’s how:

1. Annotate your entities (e.g., @ApiResource) and boom: CRUD + OpenAPI docs auto-generated.
2. Need GraphQL? Add @GraphQLQuery—same entities, new format.
3. Complex filtering? Use @ApiFilter(SearchFilter::class) or write custom filters (e.g., UuidFilter).
4. Custom responses? Extend AbstractItemNormalizer or use DTOs.
5. Deploy: Zero config—works with Symfony Flex or Laravel’s api-platform/laravel bundle. Pro tip: Use api-platform generate:bundle to scaffold a full API project in minutes. Gotchas:

• Metadata caching: Clear var/cache/dev after schema changes.
• GraphQL limits: Federation requires api-platform/graphql.
• Laravel quirks: Eloquent relations need @ApiProperty(iri="...") for Hydra."