How professional services teams can drive modernization

Modernization is a commercial lever, and your PS team is best positioned to pull it.

At Propel 2025, Benjamin Sandmann, VP of Worldwide Professional Services at MongoDB, made the case for why Professional Services should be at the forefront of legacy transformation. 

If you’re looking to see how PS teams can assess readiness, align stakeholders, and position PS as a proactive driver of modernization and long-term value, here are the key takeaways from the session

Solve for the ecosystem, not just the product

The success of a product hinges not on what it does in isolation, but on how deeply it's embedded in the broader transformation the customer is pursuing. 

For example, in MongoDB’s case, telling a company to swap out their legacy database for MongoDB doesn’t move the needle. Customers aren’t looking for a new database. They're looking for better performance, faster iteration, and more scalability.

To get that outcome, it’s not just the database that needs to change, it’s the application, the architecture, and the platform it runs on. 

Early in their growth, MongoDB’s professional services were focused on the core product and fixing bugs, helping early adopters get unblocked, and offering hands-on support and tactical advice. But as they grew, it became clear that scaling inside enterprise environments needed a different approach. Customers didn’t resist MongoDB because the tech wasn’t good. They were stuck because:

• Legacy systems hadn’t been touched in over a decade
• Internal teams lacked modern development practices
• Business processes were optimized for the old architecture
• Replacing the database touched too many unknowns

They expanded the scope of their services to lead the entire modernization journey:

• Moving apps from legacy platforms to modern infrastructure
• Re-architecting code to take full advantage of MongoDB’s capabilities
• Streamlining deployment pipelines to match the speed of development

They built the Modernization Factory, a dedicated team focused on full-system transformation:

• End-to-end modernization, not just database migration
• Internal engineers and partners trained to build microservices and re-architect apps
• AI-led accelerators that could significantly cut down timelines

Before AI, modernization timelines looked like this:

• Legacy path: 30+ months
• Competitors: ~26 months
• MongoDB with top developers: ~22 months

With AI, they were able to shrink migration timelines to four months and reframe the dialogue around change to focus on opportunity, not risk. 

That’s when MongoDB’s value proposition started resonating because it de-risked modernization at scale. 

Use AI as a modernization engine to solve adoption barriers

When most companies think about AI, the reflex is to point it inward to:

• Automate internal workflows
• Accelerate delivery timelines
• Improve internal tooling and ops
  If you only use AI to make your internal teams more efficient, you're missing the point. The opportunity lies in making your product the obvious choice by making the path to adoption frictionless.

MongoDB’s evolution highlights this approach. They shifted focus to where AI could drive the most adoption: AI-powered application development.

They launched their own “modernization factory” as an in-house engine focused on end-to-end change, not just data storage, but how apps get built and deployed. Early efforts started with data prep for AI use cases. But the team quickly realized the bigger opportunity was app development, where AI could break bottlenecks and accelerate adoption.

Key moves included:

• Teaching global SIs to build microservices around MongoDB
• Packaging modernization templates to help customers tackle legacy architecture
• Using AI to automate and accelerate core development tasks

Instead of treating PS as a support function, they repositioned it to lead the charge in digital transformation. AI made that scale possible.

Don’t reduce your AI strategy to code generation alone 

There’s a tendency to equate AI’s role in software development with just code generation. But that’s a narrow slice of the actual effort involved in application modernization.

Instead of focusing solely on code generation, MongoDB built agentic frameworks that used AI reasoning to compress the entire development lifecycle. The team built a chain of agents that could:

• Read legacy logic and map it to functional blocks
• Design new system architectures using clean separation of concerns
• Generate code aligned with best practices and organization-specific patterns
• Run validation and QA at each stage, not just at the end
  
  

With this approach, they reduced the time per procedure from 800 hours to 90 hours, and eventually to 40 hours.

By focusing on agentic workflows and closed-loop feedback, they created services that scaled like software. AI’s biggest wins often show up before and after the code, through smarter analysis, faster regression, and reduced manual work. Reusable frameworks and agent-based design made that possible.

This had ripple effects:

• Projects that used to require months of SOW negotiations now get greenlit in weeks
• AI-enhanced delivery teams became the wedge into long-term platform adoption
• The value proposition moved from feature parity to speed of transformation

If you're running similar services-led motions, here are a few lessons from MongoDB’s journey:

• Don’t sell AI as a feature. Show how it changes the service delivery curve
• Build agent chains that are reusable, not project-specific
• Anchor ROI in developer leverage and IT capacity, not just hours saved
• Position services as a path to faster transformation, not an add-on to the product

Experiment with an AI incubator model

To accelerate enterprise AI adoption, MongoDB implemented a structured incubation model that transforms proofs of concept into full-scale modernization. It starts with a clearly defined qualification framework for sales, outlining what the vendor commits to bring and what the customer must provide in return. 

The three-month AI incubator delivers early wins, breaks internal political inertia, and gives both sides the insight needed to map out what a larger modernization effort will look like. 

Core elements of MongoDB’s AI incubator model include:

• Structured qualification: Guardrails define project readiness—what’s delivered, what’s expected, and how success is measured.
• Clear next steps: Customers know upfront that if the prototype succeeds, they’re expected to scale, typically by migrating 5–10 workloads.
• Productized but flexible: The incubator is standardized enough to scale, but adaptable enough to meet each customer's real-world complexity.
  
  

A key driver of this approach is forward deployment—a deliberate strategy to embed technical and business talent inside the customer’s environment. These team members participate in scrums, absorb daily workflows, and map human decision-making into agentic logic.

Two roles make this possible:

• Forward-deployed engineers: Work with/inside dev teams, convert human reasoning into code, and design agentic frameworks aligned to real workflows. 
• Embedded business analysts: Identify hidden inefficiencies, challenge outdated processes, and ensure AI solutions match how the business actually operates.

Behind the scenes, a core engineering team works asynchronously to deliver reusable AI agents and accelerate delivery.

The incubator goes beyond delivering a POC. It lays the foundation for a modernization factory, a bespoke AI assembly line within the customer’s ecosystem. 

The AI Factory model: A shift from modernizing tech to modernizing the business

Looking ahead, the team is extending this model into AI Factories—shifting from technical modernization to rethinking business processes themselves. Just as the Modernization Factory accelerates code, the AI Factory aims to automate reasoning across core business functions.

Most companies over-index on the 5% of total cost of ownership that’s visible—tech spend. They ignore the 95%: broken development processes, inefficient services, and business workflows that block adoption. When a customer doesn’t pick your product, it’s often not because of the product itself. It’s because everything around it is too hard to work with.

Zoom out further, and even that 95% becomes another small slice of the real problem. What C-level leaders are increasingly concerned with isn’t just modernizing their tech stack. They’re asking: Can you modernize my company?

That’s where the AI Factory comes in—less on infrastructure, more on transforming the way people and teams work.

Today, multiple teams—SDRs, CSMs, services overlays—all chase the same leads, ask the same questions, and rely on manual discovery and scoping. This approach is redundant, inefficient, and often expensive. 

There is a better way to approach this. Most modern platforms already collect the signals: telemetry on usage, failure events, and support ticket patterns. This data can surface issues in real-time.

What changes the game is automating the workflow such that: 

• Issues are detected through telemetry
• AI triages and scopes the problem.
• A solution is proposed, collateral is created, and a tailored talk track is generated, all automatically.

This flips the model. Instead of using humans to spot and scope problems, humans are brought in after a solution is shaped.

The long-term vision isn’t just about optimizing cost. It’s about changing the structure entirely. Imagine a services org built on AI agents—diagnosing, proposing, closing. This way, the org chart evolves from being headcount-driven to logic-driven. Companies that figure this out won’t just lead on tech. They’ll lead on how modern businesses operate.

Check out the rest of our Propel25 recaps here for more insights from the industry’s best.