Backend engineering / PHP
PHP development.
Web backends, APIs and content systems.
Define the data, permissions and operating model before choosing a framework. Plan a new PHP product or an existing-code takeover with tested upgrades, predictable queries and a handover another team can run.
Discuss PHP requirements โContents ยท PHP
Start with the product and inherited constraints.
PHP work can include a SaaS backend, REST API, admin interface, customer portal, content platform, CMS integration or an existing application needing maintenance. Identify users, records, permitted actions, business invariants, provider interfaces and receiving-team needs first. A server-rendered app and a headless API have different interface and operating responsibilities.
PHP architecture can combine Laravel, Symfony, CodeIgniter or WordPress with Composer, database access, caching, jobs and CI. Choose the framework and components for the workflow. Inspect the actual stack and custom boundaries of any proposed base before committing to a feature or integration.
Browser and mobile clients need versioned API/auth/data contracts. Heavy data/model work, media processing, realtime connections and existing team skills may justify separate services, but a language label cannot establish universal cost, speed or capacity. Compare the actual workload and maintained dependencies.
A handover needs build, data and recovery evidence.
Specify source/history, PHP/extensions, Composer lock/configuration, framework packages, schema/migrations, tests, API documentation, scheduler and worker settings, deployment files and runbook. Demonstrate a clean install/build and backup restore by the receiving team. Transfer authorised access securely rather than committing secrets or sending live keys in documentation.
Separate rights in custom code from reusable bases, packages, themes/plugins, templates, data and external APIs. Agree confidentiality, IP assignment, permitted reuse, branding, support and exit terms in writing. Historical universal ownership, NDA timing, included support and immediate independence claims are not verified current offers.
Compare runtimes and frameworks without a universal winner.
- Request lifecycle: ordinary PHP-FPM request handling differs from long-lived PHP workers. Node.js, Python and other deployments also need actual process, concurrency and state-lifecycle checks.
- Ecosystem: compare maintained Composer packages, CMS/framework integrations and required Python/JavaScript libraries, with versions, licences and ownership. Package totals do not prove fit.
- Productivity: generators, admin tools, templates and migrations can reduce some setup work; none supplies the application business rules or guarantees an earlier release.
- Hosting: verify required PHP/extensions, database/cache, jobs, scheduler, storage, networking, updates and recovery. Shared hosting or a cloud label does not establish suitability or cost.
- Workload and team: compare actual CMS, SaaS, API, realtime, model/data, existing-code and receiving-team needs. No language guarantees the widest hiring pool or lowest bill.
The source heading also names Ruby and Java beyond its PHP/Python/Node comparison columns. Keep those as alternatives to assess through their library, hosting and team constraints, not invented rankings. A hot path can be a separate measured service without forcing a whole-product rewrite.
Seven buyer decisions before a PHP engagement.
Is PHP a fit for this product?
Inspect actual web/CMS/API needs, existing code, dependencies, team and deployment. Modern syntax does not independently make a system safe or fast.
Which PHP option?
Compare Laravel conventions, Symfony components, CodeIgniter scope and WordPress editing/plugin needs against the actual domain and receiving team. No framework is universally the fastest route.
What does an old runtime mean?
Check current official PHP/framework/package support and the installed build. Add regression tests and plan a compatible target rather than treating every historical vulnerability as present.
Can abandoned code be taken over?
Establish authorised repository/host/database/provider access, backups, an isolated working environment and an audit before selecting repair, upgrade or partial replacement.
What is insecure or slow?
Review queries, output, authentication, uploads, dependencies, configuration and measured bottlenecks. Prioritise actual risks and test the chosen changes.
Where should it run?
Verify runtime/extensions, jobs, scheduler, storage and operating duties on the proposed host; choose PHP-FPM or long-lived workers deliberately.
Who takes responsibility?
Compare current project, team and ongoing options with named review, security, data, release and support owners instead of adopting historical staffing terms.
Modules and repositories need explicit responsibilities.
The source proposes feature modules containing controllers, services, repositories and requests, with shared authentication, audit and media capabilities. Define ownership, dependencies, transaction boundaries and public contracts around actual business behaviour. A directory layout does not guarantee a new module can be added quickly without breaking another.
Controller/request handling can stay separate from use cases and persistence where that makes testing clearer. A repository interface may be useful, but wrapping every ORM call does not automatically improve correctness or isolation. Review permitted data scope, query behaviour and side effects rather than treating one pattern as universally required.
Parameterised raw SQL can be appropriate for a justified query; the presence of raw SQL alone is not proof of injection or poor architecture. PHP PDO documentation distinguishes parameter values from identifiers and other query structure, which still require controlled construction. Never interpolate untrusted sort fields, column names or fragments on the assumption placeholders cover them.
Strict types and readonly do not validate the business.
PHP type declarations can constrain arguments, returns and properties, but input shape, ownership, ranges and business invariants still need validation. strict_types is per-file and scalar-call behaviour follows the calling file; declaring it in a repository does not force every external caller to pass uncoerced values. Internal calls and scalar details also follow the documented rules.
Enums constrain declared alternatives but do not establish allowed state transitions for a particular user. A vendor ID being an integer does not authorise that vendor. Validate route/body/query data, optional values and error semantics before performing an operation, then enforce domain and database constraints where needed.
Readonly properties prevent certain reassignment, not all interior mutation of referenced objects. Do not equate readonly classes with a deeply immutable domain or tamper-proof state. Static analysis and code style checks provide scoped evidence, not runtime input validation, object permissions or a compliance certificate.
The vendor-orders sample needs access and query checks.
The final OrderRepository example takes an integer vendor ID and optional OrderStatus. It queries orders with items/customer eager loading, filters vendor_id, conditionally filters the enum value, sorts by latest and returns a length-aware paginator. This is a concrete read pattern, not an implemented marketplace permission system.
- The caller authorization is unshown. Resolve the allowed vendor from the authenticated principal and tenant policy; do not accept an arbitrary supplied ID as permission to another vendor records.
- Eager loading items/customer addresses those relationship paths, not every later mapper, accessor, nested relation or inverse relationship. Inspect the real response and generated SQL rather than promising no N+1 anywhere.
- paginate retrieves a total count before records, and eager loading can add relationship queries. The sample is not a single-query guarantee. Select total-count, simple or cursor pagination according to the actual UI and data behaviour.
- latest needs a deterministic ordering contract when timestamps tie. Review supported cursor/order keys, concurrent inserts and stable navigation across pages.
- Customer and order fields need explicit output selection and privacy checks. Loading a relation does not establish permission to disclose every customer attribute.
- The sample does not show writes, transaction rollback, idempotency, stock or payment consistency. Do not infer a complete safe checkout from a read repository.
Test invalid/forbidden vendor scope, empty and large histories, enum filtering, query counts, sensitive fields and page-boundary behaviour against the actual database. Complete the surrounding permission, API and data-layer implementation before deploying the pattern.
Technical example
Source sample, not an installed backend or verified deployment. The limitations above apply.
<?php
declare(strict_types=1);
namespace App\Repositories;
use App\Enums\OrderStatus;
use App\Models\Order;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;
// Vendor orders: eager-loaded, optionally filtered by a backed enum, paginated
final class OrderRepository
{
public function getByVendor(int $vendorId, ?OrderStatus $status = null): LengthAwarePaginator
{
return Order::with(['items', 'customer'])
->where('vendor_id', $vendorId)
->when($status, fn ($query) => $query->where('status', $status->value))
->latest()
->paginate(25);
}
}Query, transaction and cache rules need separate evidence.
Define database constraints, indexes, query plans, transaction boundaries, isolation and concurrency rules for the domain. Eloquent models or a repository interface do not establish a correct ledger, duplicate-safe payment or safe concurrent inventory update. Include stale writes, repeated webhooks and reconciliation tests.
Choose eager loading, projections and bounded pagination for the actual access pattern. Measure slow SQL, database waits, resource use and response serialization on representative data. A cache or a newer runtime is not proof that a slow query has been fixed or that every workload becomes cheaper.
Redis cache needs tenant/user-safe keys, expiry, invalidation, consistency and capacity decisions. It is not authoritative money or inventory state. Profile the selected production-like image/configuration with OPcache and debug settings checked; distinguish cold startup, warmed operation and overload/failure behaviour.
Horizon monitors Redis queues, not every backend.
The source proposes offloading email, reports, media and provider work to jobs. Define the actual broker/backend, worker supervision, timeouts, retries, backoff, ownership, retention and safe replay. A successful enqueue is not completed work or exactly-once business execution.
Current Horizon documentation requires Redis and says it is not compatible with Redis Cluster. Do not call Horizon a universal manager for every Laravel queue connection. Check dashboard access, failed/stale jobs, worker restarts and release compatibility in the selected topology.
Coordinate jobs with committed database state and provider effects. Design idempotency, outbox/reconciliation or other appropriate mechanisms for uncertain outcomes. Verify webhook signatures, replay rules and quotas. A timeout may follow an accepted payment, so automatic retry must not duplicate it.
PHP-FPM and persistent workers have different state risks.
An ordinary request lifecycle is not a universal PHP guarantee. Laravel Octane boots and retains an application while serving requests; documentation warns about stale request/container injection and application-maintained global state. Review long-lived workers, singletons, static arrays, leaks, resource cleanup and restart policy before choosing that model.
For PHP-FPM or another server, verify supported runtime/extensions, process/memory limits, OPcache, TLS/proxy behaviour, uploads/storage, database/cache access and monitoring. Plan scheduler and job processes separately from the web request. Do not infer every shared host lacks workers or every cloud supplies them; inspect the actual offering and configuration.
A container helps package a chosen runtime but does not establish environment parity or operating readiness. Include updates, secrets, storage/network policies, migrations, health checks, backups and a named receiving-team operator. No paid infrastructure or production backend is provisioned here.
Review query, output, identity and deployment together.
Use prepared parameter values with controlled query structure, context-appropriate output escaping, password APIs and an explicit authentication/authorization model. Query builders do not make unsafe raw fragments safe. Review CSRF for the actual cookie model, token validation, object/tenant/field access and rate/resource limits.
Validate uploads and delivery paths, store sensitive files appropriately, and review plugins, dependencies, permissions and debug output. Dependency audit, PHPStan and a scanner cannot prove that no vulnerabilities remain. A supported runtime removes one source of risk; it does not validate the application.
Laravel deployment guidance requires serving the public entry point rather than exposing the project root, and disabling production debug output. After config caching, application code should read configuration rather than assume .env-backed env calls still work. Externalising credentials needs actual secure delivery, access and rotation, not only an example file.
Three engagement shapes with explicit base/custom boundaries.
- Base adaptation: inspect actual product features, stack, rights, apps/admin and provider setup; separate branding/configuration from extra PHP/API work.
- Custom PHP build: agree records, interfaces, roles, integrations, jobs, acceptance, deployment and receiving-team handover.
- Ongoing development: define priorities, review/release cadence, PHP/framework/Composer updates, security and incident duties, recurring costs and exit support.
Confirm present availability and terms. Historical fixed prices, minimum budgets, retainers, cancellation notice, included support and launch guarantees are not verified current offers.
Six quality areas with observable results.
- Review: module/use-case boundaries, request validation, permissions, query structure, transactions, migrations and dependencies.
- Automated tests: domain/repository/API and actual database/provider-boundary tests, including invalid, forbidden, duplicate and failure cases.
- Production-like profiling: runtime/extensions, OPcache, debug/config caches, queries, worker/pool waits, load and recovery with representative data.
- Handover: source/history, Composer lock, environment setup, OpenAPI, migrations, tests, worker/scheduler config, secure access transfer and runbook.
- Release: reviewed artefacts, migration rehearsal, public entry point, TLS, secrets, worker reload, smoke checks and restored backup.
- Operations: exceptions, slow endpoints, failed/stale jobs, backlogs and alerts with privacy/retention and named incident/update owners.
A style rule, static analysis level, coverage threshold or green build is scoped evidence, not proof that defective code cannot reach production. Keep developer tools separate from exposed production diagnostics and record the tests actually run.
Sixteen technology areas to select and maintain.
- PHP: supported runtime/extensions, type behaviour and OPcache.
- Laravel: compatible framework, auth, data and jobs.
- Composer: lock, autoloading, platform requirements and audit.
- Symfony components: selected capabilities, versions and integration.
- MySQL: constraints, indexes, query plans and recovery.
- Redis: distinct cache, queue or session roles and durability.
- Docker: image/configuration, patching and storage.
- WordPress: editor/plugin/theme rights, updates and permission model.
- PostgreSQL: chosen data/query features and recovery.
- API Platform/chosen tooling: schemas, errors and actual permission tests.
- PHPUnit: compatible unit and integration tests.
- Horizon: Redis-only queue monitoring and secured dashboard.
- PHPStan/chosen analysis: configured scope, findings and limitations.
- AWS/DigitalOcean/chosen host: verified capabilities, operations and costs.
- Blackfire/chosen profiler: representative evidence and data privacy.
- Pint/chosen style tools: agreed rules rather than proof of correctness.
Five stages from brief to controlled handover.
- Brief/confidentiality: users, data, existing code/access and receiving-team needs.
- Scope/plan: base/custom fit, framework/runtime choices, dependencies, acceptance, current quote and owners.
- Build/demonstrate: inspect real API/admin/job journeys and open issues at agreed checkpoints.
- QA/release preparation: contracts, data/permission, integration/load/security checks and migration/recovery rehearsal.
- Launch/handover: approval, controlled release, secure access transfer, runbook/training, monitoring and agreed support.
External provider accounts, identity/compliance onboarding, data preparation and any separately included mobile-store review have different owners and dependencies. No source first-commit, NDA-turnaround, build or response-hours interval is a current promise here.
Quote inherited risk and operating work explicitly.
Get a current itemised quote separating reusable-base adaptation, custom PHP scope, takeover/upgrade and ongoing development. Define milestone acceptance, change control, third-party rights, hosting/provider bills and exit support. A historical price band or no-hidden-fee slogan is not a current offer.
- API/admin/interfaces, roles, tenant/resource/field access and audit.
- Schema/query complexity, media, headless CMS and content migration.
- Payment, Mailchimp, CRM and other provider contracts, reconciliation and failure behaviour.
- Realtime, jobs, multi-region and load/recovery requirements.
- Existing PHP/framework/packages, abandoned dependencies, test coverage and receiving-team needs.
The original general/custom/project-record intervals differ; do not choose a duration from them as authoritative. Require a scope-specific schedule and written quote after inspecting existing code and external dependencies.
Composer requirements do not force environment parity.
Inventory runtime/extensions, framework/plugins, Composer dependencies, build/deploy, queries, data, secrets and tests. PHP publishes an active/security support policy and branch matrix; check the current table and installed build rather than treating every PHP8 release as supported or assuming all later vulnerabilities affect every app.
A composer.json PHP constraint limits dependency compatibility, it does not install the same binary/extensions everywhere. Composer config.platform can even emulate a different platform for resolution; run check-platform-reqs against the real deployment. Check lockfiles, extensions and actual web/CLI/worker runtimes together.
Use applicable migration guides, compatibility tools and Rector where appropriate, then test business, encoding/serialization, query and permission behaviour. Audit no-framework code without assuming it must be rewritten; add boundaries and tests incrementally when supported by evidence. Do not promise uninterrupted upgrades without a verified release/recovery plan.
Before takeover changes, confirm authorised access, backup/restore, isolated staging and a written repair/upgrade/replacement assessment. Rotate exposed credentials through an authorised secure process. Upgrading PHP is not a substitute for resolving unsafe application code or abandoned integrations.
The recorded WHMCS scope contains unresolved identity and reuse claims.
The source describes Intercopy WHMCS as a custom WHMCS plugin and CRM for NFT management, while a nearby testimonial describes an International Copyright Organization registration/billing workflow. Preserve both requirement descriptions as unresolved source material; do not silently equate the organisations or treat the testimonial as proof of the same implementation.
It also says no fitting base while claiming reused custom-build blocks. Clarify what product base, shared components and custom scope mean. Inspect the actual WHMCS/module APIs, licensing, registry/CRM data, permissions, billing reconciliation and upgrade compatibility rather than adopting application/reuse/integration counts.
Client association, delivery intervals, source transfer and outcome claims are unverified here. The separate APAC headless-content example retains multi-tenant content types, API contracts, Vue, cache and jobs as a requirement reference, not a proved Laravel deployment or measured expansion result.
PHP delivery review and handover.
The acceptance review can cover forbidden vendor access, private customer fields, query counts, pagination, duplicate provider/webhook handling, a failed job, a migration and restored backup. Review code/configuration, tests and deployed operating evidence alongside the happy path. Demonstrate receiver install and release from the preserved source.
Product patterns to consider include utility billing with metering, dunning, tax rules, customer portals and tenant reporting; security dashboards with collectors, alerts, scoring and playbooks; and B2B commerce with orders, payments, credit, distributor pricing and reconciliation. Define the exact records, permissions, integrations and failure states for the selected product. These are possible project scopes, not a client portfolio.
The written scope should name the selected implementation, source and third-party rights, account ownership, release responsibilities and support terms. Include a receiving-owner walkthrough of the agreed build, tests and recovery steps, with open items recorded before acceptance.
Eight sectors become acceptance questions.
- Healthcare/life sciences: patient access, appointment APIs, audit, minimal data and specialist privacy/regulatory review.
- Telemedicine: consultation/signalling state, scheduling, secure messages and participant permissions.
- Fintech: ledger, KYC/payment boundaries, reconciliation and controlled side effects.
- Retail/eCommerce: catalogue, inventory, checkout, order concurrency and peak-load tests.
- Media/entertainment: billing, content rights and entitlements.
- Creator economy: payout ledger, paywalls, analytics and moderation.
- Transportation/mobility: dispatch, location/ETA assumptions, stale updates and settlement.
- Food/beverage: order routing, kitchen feeds, menu/pricing changes and refunds.
Twelve questions before a PHP engagement.
PHP, Laravel or WordPress?
PHP is the language; framework/CMS choices depend on domain, editing, plugins, interfaces and maintenance needs.
What does it cost?
Obtain a current itemised quote for data, roles, APIs/admin, integrations, migration and operations.
What source is delivered?
Specify repository/history, Composer lock, environment/build, migrations, tests, API docs, worker/scheduler config and runbook.
How quickly can it launch?
Agree scope, dependencies, acceptance and schedule. Base adaptation, custom work and takeover differ.
PHP or Node.js?
Compare team, workload, dependencies and measured operations, not a universal realtime or hosting stereotype.
Can it be headless?
Scope actual REST/GraphQL contracts, content/media permissions, cache and frontend/mobile integration explicitly.
What is included?
List models, APIs, admin, auth, cache, jobs, docs, tests and release duties instead of assuming a stack list is installed.
Can it serve mobile apps?
Yes as an API design option with shared/versioned contracts; mobile implementation and store work are separate.
When choose another technology?
Measure CPU/media/model/realtime constraints and team fit; a separate hot-path service may suffice without a whole rewrite.
Which PHP release?
Select a maintained compatible runtime after checking framework, extensions, packages and official support; verify the deployed platform.
Can no-framework code be maintained?
Audit risks, dependencies, data and tests, then choose repair, components or staged replacement based on evidence.
Should it be rewritten?
Compare actual risks, migration cost, feature continuity and receiving-team needs after an audit; neither preserving nor replacing is automatically correct.
Primary references for technical qualification.
Official platform, framework and API documentation checked on 17 November 2026. These support the technical checks here, not Omnistu staffing, pricing, rights, delivery or client outcomes. Recheck installed versions and configuration before implementation.
- PHP: Type declarations - Manual - php.net
- Composer platform dependencies - Composer - getcomposer.org
- Config - Composer - getcomposer.org
- Database: Pagination - laravel.com
- Eloquent: Relationships - laravel.com
- PHP: Supported Versions - php.net
- PHP: Properties - Manual - php.net
- Laravel Octane - laravel.com
- Laravel Horizon - laravel.com
- PHP: PDO::prepare - Manual - php.net
- Command-line interface / Commands - Composer - getcomposer.org
- Deployment - laravel.com
Bring the domain, dependencies and receiving-team needs.
Describe the records, users, permitted actions, integrations, existing code and operating constraints. Agree base/custom boundaries, acceptance evidence, current quote and handover before implementation.
Discuss PHP requirements โ