Laravel vs custom PHP: how to choose for your business app
When you commission a business application, someone will ask "Laravel or custom PHP?" and someone else will ask "why not just buy software?". The real question is five-year cost, risk and who can maintain it. This guide compares the three options in business terms, with examples, a scorecard and the questions to ask any development vendor.
TL;DR
- There are three options: off-the-shelf software, a framework such as Laravel, or hand-written PHP without a framework. Choose by total cost of ownership over 3 to 5 years, not by the first quote.
- Buy off-the-shelf for needs that are not your differentiator (accounting, basic scheduling, a simple store). Build when the workflow is your competitive edge.
- For most custom business apps (portals, CRMs, marketplaces, SaaS, APIs) Laravel is the safe default: security basics, structure, a large hiring pool and a published support policy.
- Plain custom PHP fits small, narrow tools such as webhook endpoints, landing pages or additions to an existing legacy system.
- Whatever you pick, insist on your own repository, standard tools, tests on money flows and an upgrade plan. A vendor's private "in-house framework" is the biggest exit risk.
"Custom software versus off-the-shelf" and "Laravel versus custom PHP" are really one decision seen from two angles: how much of the system do you want to own, and how much do you want to rent or inherit from someone else's standards? The wrong choice rarely fails in month one. It fails in year three, when changes become slow, the original developer is gone and the quote for a new feature is higher than the quote for the whole first version.
We build with all three approaches. Our Talk product runs on Laravel, our Prism platform on Yii2, and this website runs on hand-written PHP. That mix is deliberate, and the reasons are below.
The three options in plain language
- Off-the-shelf (SaaS, CMS, ready-made platform). You rent or install a finished product and configure it. Fast and cheap to start. You are limited to its features, pay per seat or per transaction and depend on the vendor's roadmap and pricing.
- Framework-based custom software (for example Laravel). A developer team builds your application on top of a mature open-source framework that supplies authentication, routing, database access, queues, validation and security defaults. You own the code. The structure is familiar to any developer who knows the framework.
- Custom PHP without a framework. Hand-written code and a few libraries. Maximum control and minimal overhead. It also means every security and structure decision is made, and must be maintained, by whoever wrote it.
Compare them on business criteria
- Time to first release. Off-the-shelf: days to weeks. Framework: weeks to a few months. Plain PHP: similar to framework for small scope, slower as scope grows because you rebuild common features.
- Up-front cost. Lowest for off-the-shelf, higher for custom. But subscription fees repeat every month and rise with growth, while custom code is a one-time build plus maintenance.
- Cost of change in year three. Off-the-shelf: cheap if your need fits, impossible if it does not. Framework: predictable. Plain PHP: depends entirely on the quality and documentation of the original code.
- Security. Mature frameworks ship with protections against common web attacks switched on by default. In plain PHP each of them must be implemented and remembered correctly. Off-the-shelf vendors patch for you, but you are exposed to their incidents.
- Hiring and handover. Framework code is readable to a large pool of developers. Plain PHP is readable only if it follows clear conventions and has documentation.
- Upgrades. Laravel publishes a major version roughly once a year, with bug fixes for 18 months and security fixes for two years, and you plan upgrades on that cycle. Plain PHP has no schedule: it is whatever your team chooses to do.
- Exit risk. Off-the-shelf: data export may be limited. Framework: low, you hold code and data. Plain PHP: low in principle, high if only one person understands it.
What a framework gives you for free
An example makes the difference concrete. Here is a small "create invoice" endpoint in Laravel. Validation, authorization, CSRF protection, escaping and database safety come from the framework:
<?php
// Laravel: app/Http/Controllers/InvoiceController.php
public function store(Request $request)
{
$data = $request->validate([
'customer_id' => ['required', 'exists:customers,id'],
'amount' => ['required', 'numeric', 'min:0.01'],
'due_date' => ['required', 'date', 'after:today'],
]);
$this->authorize('create', Invoice::class); // policy decides who may do this
$invoice = Invoice::create($data + ['created_by' => $request->user()->id]);
return redirect()->route('invoices.show', $invoice);
}
The same feature in plain PHP is perfectly possible, but each protection becomes your responsibility:
<?php
// Plain PHP: everything below is yours to write, test and remember
session_start();
if (!hash_equals($_SESSION['csrf'] ?? '', $_POST['csrf'] ?? '')) { http_response_code(419); exit; }
if (empty($_SESSION['user_id']) || !userCan($_SESSION['user_id'], 'invoice.create')) { http_response_code(403); exit; }
$customerId = filter_var($_POST['customer_id'] ?? null, FILTER_VALIDATE_INT);
$amount = filter_var($_POST['amount'] ?? null, FILTER_VALIDATE_FLOAT);
$due = DateTime::createFromFormat('Y-m-d', $_POST['due_date'] ?? '');
if (!$customerId || !$amount || $amount < 0.01 || !$due || $due <= new DateTime('today')) { http_response_code(422); exit; }
$stmt = $pdo->prepare('INSERT INTO invoices (customer_id, amount, due_date, created_by) VALUES (?, ?, ?, ?)');
$stmt->execute([$customerId, $amount, $due->format('Y-m-d'), $_SESSION['user_id']]);
header('Location: /invoices/' . (int) $pdo->lastInsertId());
A careful developer can write the second version safely. The point is that over a multi-year project with several developers, "remember every time" is where incidents come from. That is why we default to a framework for anything with logins, roles or payments.
When off-the-shelf is the right answer
Do not build what you can rent without pain. Buy when:
- The need is common and well served (accounting, payroll, email marketing, a standard online store, basic appointment booking).
- The workflow is not what makes you different from competitors.
- Per-seat or per-transaction pricing stays acceptable at your 3-year volume. Do the math for growth, not for today.
- You can export your data in a usable format if you leave.
The common middle path is to buy the core product and integrate it with your own tools, so that the data flows between systems without manual work. We cover this in our startup integrations playbook, and it is the work behind our integrations service.
When Laravel (a framework) is the right default
- Customer or partner portals, internal tools, CRMs, booking and order systems, marketplaces and SaaS products.
- Anything with user accounts, roles, payments, background jobs, notifications or an API.
- Teams that expect to grow, change developers or hire in-house later.
- Projects where the workflow is your product and will keep changing for years.
The cost is a little extra structure up front and the discipline of staying on a supported version. In return you get conventions that any competent framework developer can pick up. Other mature frameworks such as Symfony or Yii give similar benefits, and the principle matters more than the brand: use a widely adopted framework with a published support policy.
When plain custom PHP is right
- Small, narrow services: a webhook receiver, a payment callback, a cron-driven importer, an internal script. Less code, less to patch.
- Content and landing sites where a framework adds nothing and speed matters.
- Extending a legacy application that is already plain PHP, when a rewrite is not justified. See our legacy code audit checklist before deciding.
- Performance-critical endpoints where startup overhead matters, and the team has the discipline to keep them small and tested.
Plain PHP stays healthy when it follows conventions: autoloading with Composer, prepared statements, a clear folder structure, tests and a README. Without these, it becomes the legacy code the next owner has to audit.
A simple scorecard
Score each statement from 0 (no) to 2 (yes) and add up. It is a conversation tool, not a law:
Statement Score
Users log in and have different roles or permissions 0-2
We take payments or handle personal data 0-2
The workflow is our competitive advantage 0-2
It will change every quarter for the next 3 years 0-2
We may change developers or hire in-house 0-2
Integrations with several external systems are required 0-2
0-4 Look hard at off-the-shelf plus integrations
5-8 Framework-based custom (Laravel) is the likely fit
9-12 Framework, with an architecture review and a test plan up front
If the same item pushes you toward "buy" and "build", it usually means the answer is a hybrid: buy the commodity parts and build the differentiating layer.
Questions to ask any development vendor
- Will the code live in a repository owned by my company from day one?
- What framework and version will you use, and what is the plan for upgrades when it reaches end of life?
- Do you use any proprietary framework, library or code generator that only your company maintains?
- Which flows will have automated tests (payments, login, order creation)?
- How do deployments work, and can we roll back quickly?
- Who handles security updates after launch, and what does maintenance cost per month?
- Will I receive documentation and a signed assignment of intellectual property?
- Can a different team take over if we part ways? Please show an example of handover documentation.
Vague answers to questions 3, 4 or 8 predict expensive problems. If you inherit a project from a previous vendor, our legacy PHP handover guide describes how to take control safely.
How we can help
We build and rescue business applications in Laravel, Yii and plain PHP, and we will tell you honestly when buying software is the better answer. A short consultation is usually enough to decide between buying, integrating and building before you pay for development. If you already have an application and are unsure about its health, start with an audit.
Read also: How to hire a PHP developer: rates, skills, interview questions and red flags
Frequently asked questions
Is Laravel better than custom PHP?
For most business applications with logins, roles, payments or APIs, yes: it supplies security defaults, structure and a large hiring pool. For small narrow services such as webhook endpoints or landing pages, plain PHP can be simpler and faster. Pick by project type and maintenance needs, not by fashion.
Is custom software more expensive than off-the-shelf?
Usually it costs more up front and less per month. Off-the-shelf software has lower initial cost but recurring per-seat or per-transaction fees that grow with your business, and it cannot adapt to unusual workflows. Compare three to five years of total cost, including maintenance.
Can any developer maintain a Laravel application?
Any developer experienced with Laravel can read its structure quickly, which is the main handover advantage. You still need documentation, tests and a supported framework version. A vendor's private framework removes this advantage.
How often must a Laravel application be upgraded?
Laravel releases a major version about once a year. Each version gets bug fixes for about 18 months and security fixes for about two years, so plan a major upgrade every one to two years and apply minor updates regularly.
When should I not build custom software at all?
When the need is common, the workflow does not differentiate you and an existing product fits at acceptable long-term pricing. In that case buy it and integrate it with your other systems instead of building from scratch.
Free discovery call
Bring a messy stack or stalled integration - Integrono will map the smartest first move.
You get a senior take on budget traps, dependencies and whether to buy, glue or build - before paid work starts. The CEO stays in the loop.