Ask buyers who run a personalization engine what frustrates them and the answers cluster tightly: we can't tell if it's working, we use only a slice of it, the version bundled into our suite is thin, it can only personalize as well as our data and content let it, connecting it was a project, and the powerful engine assumes a maturity we don't have. What differs is which engine earns which complaint most — and, more useful still, whether a given complaint is livable, fixable, or the kind that turns a renewal into a line item nobody defends. Below is the catalog, mapped and graded. For the pre-purchase view of the same corpus, see what personalization-engine buyers wish they'd known.
The six complaints — graded
Each complaint below carries a verdict: is it something you can live with, something money and scoping can fix, or the kind of problem that turns the renewal into an expensive line item nobody defends. The grade is the useful part — every engine draws most of these, so the question is never "does it have complaints" but "which of them are dealbreakers for me."
You can't prove the lift — so it becomes an expensive line item
The complaint that ends the relationship. Personalization is sold on incremental revenue, but buyers struggle to isolate its actual contribution — the engine is on, the numbers move, and nobody can cleanly attribute the change to it. One DTC brand said the platform met its baseline needs but, for what it actually used, it was "expensive" — the license-to-value gap and the missing proof in one breath. When you can't demonstrate the lift, the cost has no defender, and at renewal a tool you can't measure is the first thing questioned. This is the personalization complaint most likely to be fatal, because unlike a UI quirk, an unprovable ROI only looks worse the longer it runs.
Named for this: Dynamic Yield · Adobe Target · Monetate · Salesforce · engines broadly
You adopt a fraction of what you bought
The quiet waste, and it's the widest in this category. Personalization engines are priced and sold on their full capability, but buyers routinely operationalize a slice of it — one brand admitted the team "wasn't fully exploiting" the platform's capabilities, running a handful of simple rules on a tool built for far more. High capability plus low adoption is pure gap: you pay for depth you never switch on. It's fixable — with a real program, a roadmap of use cases, and someone driving adoption — but left alone it compounds, because an under-used engine also makes Complaint 01 worse: you can't prove a lift you never fully deployed.
Named for this: Adobe Target · Dynamic Yield · Salesforce
The bundled version is shallow — the suite's personalization underwhelms
The complaint that reliably pushes buyers to a specialist. Personalization built into a CRM or a broader marketing suite is convenient but thin — fine for basic rules and simple recommendations, underwhelming next to a dedicated engine when buyers want real behavioral targeting and testing. In the corpus the CRM-bundled option rates near the bottom of the personalization category for exactly this reason, and Monetate and Nosto draw a version of it when personalization rides alongside search and merchandising rather than leading. It's fixable — buy a pure-play — but the buyers who defaulted to the bundled option because it was already in the stack often outgrew it and re-bought, paying twice. Match the depth to how central personalization is before you settle for what's included.
Named for this: Salesforce (CRM-bundled) · Monetate · Nosto · Adobe (suite)
The engine can't fix your data and content — garbage in
The deepest complaint, and the one buyers blame on the tool least fairly. A personalization engine acts on the data and content you feed it, so fragmented data and a thin content library cap what it can do no matter how good the algorithm is. A fashion retailer found its engine "doesn't integrate very well with other systems," which limited the data it could pull and, in turn, what it could personalize; another team was reduced to exhausting manual exports just to sync the information the engine needed. It's fatal when unaddressed because no engine out-runs its inputs — buyers who bought the tool before unifying data and building content variety got a powerful engine running on empty, and concluded personalization "doesn't work" when the plumbing never did.
Named for this: Dynamic Yield · Adobe Target · Monetate · Salesforce · engines broadly
Integration is a project — the engine can't reach the data it needs
The complaint buyers underestimate. Wiring a personalization engine to the CDP, the commerce platform, and the content stack is a services project, not a setting — and buyers describe integration friction as the practical ceiling on what they can personalize. Dynamic Yield, the highest-rated engine, is flagged specifically for integration friction alongside its cost; buyers on other engines describe manual data syncs as the stopgap when the connections don't hold. It's fixable — middleware, services, engineering time — but you pay for the fix, and until it's done the engine runs on whatever data it can reach, which is usually less than you assumed at purchase.
Named for this: Dynamic Yield · Adobe Target · Monetate
It assumes an enterprise team you don't have
Constant at the leaner end, rarely decisive on its own. Buyers repeatedly describe the sophisticated engines as "more suited for enterprise-level teams" — powerful, but assuming a data maturity, a headcount, and a testing culture a smaller brand doesn't have. A skincare brand concluded the leading engine was built for bigger teams and questioned whether it was cost-effective at their size. It's livable, because the fix is fit, not a feature: match the engine to your platform, team, and scale, and the complaint disappears. Buy above your maturity and a capable engine turns into an underused expense — which loops straight back to Complaints 01 and 02. The Shopify-native engines like Rebuy draw this complaint least, because they fit a narrower job to a leaner team.
Named for this: Dynamic Yield · Adobe Target · Rebuy (the fit counter-example)
The stories behind the complaints
The counter-current: the engine is rarely the whole problem
Listen closely and most of the loudest complaints are really about what surrounds the engine, not the engine itself. "Can't prove the lift," "under-adopted," "data and content aren't ready," and "assumes an enterprise team" are all, at root, the sound of a team that bought a tool before building the program around it — the data, the content, the testing discipline, and the owner that turn an engine into results. The interviews bear it out: the buyers happiest with personalization treated it as a data-and-content program with a named owner and a measurement plan; the unhappiest expected the engine to supply all of that itself. That's why the verdicts matter. Before you conclude the engine is the problem, separate the complaints the vendor owns — a genuinely shallow bundled tool, real integration friction — from the ones your operating model owns. Only the first kind is a reason to switch; the second follows you to the next engine.
What this means — whether you run one or you're buying one
If you already run a personalization engine, sort your own complaints with the grades above: the livable one (an engine built for a bigger team than yours) is a fit-and-scale question, the fixable ones (low adoption, a shallow bundled tool, hard integration) are money-and-program questions, and the fatal ones (a lift you can't prove, a data-and-content foundation that isn't there) are the signal to fix the foundation or plan an exit rather than renew on faith. If you're evaluating one, assume the shared complaints — unprovable lift without a measurement plan, dependence on your data and content — come with the category, and build the program to answer them before you turn the engine on; then decide which differentiating complaint you can tolerate, because you're choosing between a deep engine you might under-use, a bundled one that's shallow, and a fitted one that ceilings out. There's no personalization engine without complaints. There's only the set you can live with — and the ones that are really about you, not the tool.
Common questions
Why do personalization projects underdeliver?
Rarely because the engine is bad — almost always because of what surrounds it. The complaint buyers raise most is that they can't prove the lift: the tool is live, but its impact on revenue is hard to isolate, so it becomes an expensive line item nobody can defend at renewal. Underneath sit the real causes. The engine is only as good as the data and content feeding it, and most teams' data is fragmented and their content library too thin. Adoption is low — buyers use a fraction of what they bought. And personalization needs a dedicated owner and a testing discipline, not a set-and-forget switch. The projects that underdeliver treated personalization as a tool purchase rather than a data, content, and ownership program, and the engine took the blame for gaps it was never going to fill.
Which personalization engine has the fewest complaints?
There isn't a single cleanest one — the complaints sort by engine and by fit. Dynamic Yield is the highest-rated in our corpus and leads on depth and support, but buyers flag it for integration friction, cost, and being "more for enterprise" than a lean team needs. Adobe Target is the most-rated and the enterprise default for large stacks, carrying the complexity and team-dependence that comes with that. The Shopify-native engines like Rebuy draw fewer depth complaints because they fit a narrower job well. And the CRM- or suite-bundled personalization rates near the bottom — cheaper to turn on, but shallow. The useful question isn't "which engine is best" but "which complaint can I live with": a deep enterprise engine you'll under-use, or a simpler one that fits but ceilings out.
Is bundled personalization in my CRM or suite good enough?
Often not — it's the complaint that most reliably pushes buyers to a pure-play. Buyers describe the personalization built into a CRM or a broader suite as convenient but shallow: fine for basic rules and simple recommendations, underwhelming next to a dedicated engine when they want real behavioral targeting, testing, and depth. In our interviews the CRM-bundled option rates near the bottom of the personalization category for exactly this reason. That doesn't make it useless — if your needs are basic and you value one fewer vendor, it can be the right call. But if personalization is a core growth lever, the buyers who leaned on the bundled version tended to outgrow it and re-buy a pure-play, paying twice. Match the depth of the tool to how central personalization is to your revenue before defaulting to what's already in your stack.
Do I need clean data before personalization will work?
Yes — it's the failure underneath most personalization disappointment. A personalization engine acts on the data and content you give it, so fragmented data, thin content, and weak integration cap what it can do no matter how good the algorithm is. Buyers describe engines that couldn't pull the data they needed, teams reduced to manual exports to sync information, and content libraries too shallow to feed the personalization the tool was capable of. The order that works: unify and clean the customer data, build enough content variety to personalize against, and wire the integrations first — then turn on the engine. Buying the engine before the foundation is ready is the most common way personalization becomes an expensive tool running at a fraction of its potential. The algorithm is rarely the constraint; the data and content plumbing almost always is.
This is the aggregate. Your stack is specific.
Running a personalization engine and wondering if your complaints are normal? Do a 15-minute interview about your own stack and get this analysis personalized — which of these gripes peers on your engine share, which are livable, and which are the ones that end in an expensive line item nobody renews.
Get my personalized briefNo password needed · your interview is anonymized before it ever informs a page like this one.