Running Symfony?
Symfony app stuck on an old major or Doctrine dragging? We bring it back.
Symfony is the PHP framework that enterprises keep because it is thorough and keep away from because major upgrades are a project. We work the Doctrine schema, the service container, the Flex recipes and the deprecations until a Symfony 4 application can run as Symfony 7, or a slow Doctrine query stops dominating the response time budget.
- Since 2015Fixing technology
- FreeEstimates
- US teamReal engineers
symfony-prod.log
still failing
What it is
Symfony at a glance
Symfony is a PHP web framework first released in 2005 by Fabien Potencier at SensioLabs, now maintained under the Symfony SAS umbrella. It is one of the two dominant PHP frameworks, alongside Laravel, and has a reputation for being the more architectural of the two.
The framework is built as a set of decoupled components (HttpFoundation, Routing, DependencyInjection, Form, Security, Serializer and many others) which are used widely outside Symfony itself. Drupal, Magento, Laravel and Composer all depend on Symfony components. Major releases land on a two-year cadence with Long Term Support versions and a published deprecation path.
- Type
- PHP web framework and component library
- First released
- 2005 public 1.0
- License
- MIT
- Maintained by
- Symfony SAS and the Symfony community
- Typically used for
- Enterprise web applications, APIs, CMS platforms, long-lived PHP products
The honest version
Symfony pros and cons
No technology is all upside. This is where Symfony earns its place and where it tends to cause trouble.
Where Symfony is strong
Components rather than a monolithEvery piece can be used alone or replaced. That modularity is why Symfony code tends to age better than more opinionated frameworks.
Strong dependency injectionAutowiring, autoconfiguration and compiled containers make service definitions clear and testing easier than manual wiring.
A deprecation path you can actually followEach major release is preceded by deprecation warnings in the minors, so a disciplined team can keep up without emergency rewrites.
Doctrine ORM and DBALA mature data layer with migrations, query builder and plain SQL options, good at modelling complex domains and auditable queries.
Security component with real depthAuthentication, authorization, firewalls and voters cover scenarios that most framework auth libraries hand-wave past.
Enterprise reachSymfony is routinely accepted inside large organisations in a way smaller frameworks are not. Hiring senior PHP engineers who know it is straightforward.
Where Symfony bites
The learning curve is steeper than LaravelDependency injection, event dispatching and the container compiler are powerful and take time to internalise. New engineers are productive later than in more opinionated stacks.
Major upgrades are a project, not a weekendA Symfony 4 to 7 jump across a real application means Flex recipes, deprecated APIs, bundle replacements and sometimes Doctrine major bumps. Nobody does this casually.
Doctrine is heavier than many apps needEntity managers, unit of work and lazy loading perform well when used correctly and penalise naive usage with N+1 queries and memory bloat.
Cache clear during deploy is non-trivialThe compiled container cache has to be warmed carefully, and a cold cache on a busy site is an outage you have to design around.
Bundle ecosystem has legacy weightMany bundles exist, some are unmaintained, and picking the right one requires knowing which have survived into the current majors.
Error messages can be baroqueA container compile error can produce a stack trace that is accurate and essentially unreadable until you know what to look for.
Sound familiar?
Common Symfony problems we fix
The Symfony problems that bring people to us, and what you have once each one is fixed.
ServiceNotFoundException: non-existent service
The container compile fails after a refactor
A service was renamed, a bundle was removed, or an autowired dependency references a class that moved namespaces. The compiled container will not boot until the graph is consistent.
Container compiles clean
UniqueConstraintViolationException on INSERT
Doctrine persists fail on race conditions
Two requests check for a row that does not exist and both insert it, which the unique index catches second. ON CONFLICT or a serialisable transaction is the fix, not retries alone.
Writes race-safe at the database
Doctrine query took 4213ms
Entity queries dominate response time
Lazy loading inside a loop producing N+1 queries, or a JOIN that fetches a whole object graph. Partial objects, DTOs or raw DBAL rescue the hot path.
Hot queries back inside budget
Not setting handle_all_throwables is deprecated
Deprecations pile up before a major upgrade
A 6.x running with 7.x deprecation warnings in the log is on the right track; a 4.x with none of them silenced is a cliff. Clearing them one minor at a time is the honest path.
Deprecation log clean
CircularReferenceException
Services reference each other in a loop
Two services need each other at construction time and the container cannot resolve the order. Converting one to a lazy service or breaking the cycle via an event is the way out.
Service graph acyclic
ParameterNotFoundException: database_url
Config parameters missing at runtime
An environment variable not set in the target environment, or a .env file not loaded in the deploy artefact. Validating required config at boot catches it before the first request does.
Config validated at boot
LogicException: Rebuilding the container when kernel booted
Container rebuilds during a request
A long-running worker, a Messenger consumer or a test harness tries to rebuild the container after the kernel is up. The right fix is building the container once per process, before anything else.
Container stable through the process
What we do
Symfony help, from legacy rescue to day-to-day upkeep
Pick off a slow Doctrine query, or trust us with the whole Symfony estate.
01
- Major upgrades
- Symfony 3, 4 or 5 brought to a current major with Flex recipes applied, deprecations cleared and tests running green before and after.
02
- Doctrine performance
- Finding the N+1s, the chatty hydration and the missing indexes, and reshaping the hot queries so response times recover.
03
- Dependency injection
- Service definitions reviewed, autowiring tightened, and the container made easier to reason about.
04
- Security
- Authentication, authorization and voters configured against your real roles and threats rather than a generic recipe.
05
- Legacy modernisation
- Older codebases brought up to modern PHP, with gradual refactors rather than a rewrite that never ships.
06
- Managed Tech
- Watching deprecations, rolling minor upgrades, keeping bundles current, and on call when Doctrine does something strange in production.
How it works
From first message to fixed
1
Look Free estimate
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
2
Fix
We fix the cause, not the symptom. If something is down, getting it back up comes first.
3
Harden
Backups, monitoring, updates and access, so the same problem can't quietly come back.
4
Hand back or stay on
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
Running Symfony alongside something else?
We work on the whole stack, so the problem can be wherever it actually is.
Our Symfony 4 application needs to reach Symfony 7, how long will that take?
The honest answer depends on test coverage and bundle choices. A well-tested app with mainstream bundles can usually move one major per week once the deprecations are being cleared minor by minor. An older application with custom bundles and thin tests is a month or more per major, mostly spent on API changes and Flex recipes. We estimate honestly after a short audit; no large rewrites quoted before we have seen the code.
Why are our Doctrine queries slow?
The three most common causes are N+1 queries from lazy associations traversed in a loop, over-hydration that loads whole object graphs when a DTO would do, and missing composite indexes for the columns in the WHERE and ORDER BY. The profiler toolbar in dev and a slow-query log in production are usually enough to pinpoint which is dominating.
How do we handle Symfony cache clear during deploy without an outage?
Warm the container cache during build, ship the warmed cache in the deploy artefact, and avoid clearing cache at runtime on production. The APP_CACHE_DIR has to be writable and preferably local to the instance so a cold restart does not become a cold cache under traffic.
Can we gradually move a legacy application onto Symfony?
Yes, and this is often the right path. A Symfony front controller can route some URLs to the new code and the rest to the legacy handler, letting you move modules one at a time. The pattern is sometimes called strangler-fig; the key is a clear seam at the routing layer and a deploy process that handles both halves.
How much does Symfony help cost?
Our quotes are free. Describe the application, the Symfony version and what is misbehaving, and we return a scope and a price without any commitment on your side.