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.

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.
Doctrine performance
Finding the N+1s, the chatty hydration and the missing indexes, and reshaping the hot queries so response times recover.
Dependency injection
Service definitions reviewed, autowiring tightened, and the container made easier to reason about.
Security
Authentication, authorization and voters configured against your real roles and threats rather than a generic recipe.
Legacy modernisation
Older codebases brought up to modern PHP, with gradual refactors rather than a rewrite that never ships.
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.

Questions

Symfony questions

Something else? Call+1 737 727 7327

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.

Free estimate

Symfony giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.