Developer Spotlight: How SJR modernizes website personalization with Foundry

Shipping reliable personalization at scale with Microsoft Foundry

Personalization at scale has always been a moving target. Every website needs to deliver the right content to the right person, but for developers, that often means wrestling with unstructured data, broken schemas, and brittle pipelines that can’t keep up.

GX Manager is SJR’s answer, a system built on Microsoft Foundry that automatically ingests, enriches, and personalizes web content in real time. It scrapes text, images, and PDFs from client sites and uses Azure Content Understanding in Foundry Tools to tag and describe them. Then it dynamically assembles pages so each visitor sees more accurate, brand-safe content tailored to their context.

For SJR, a WPP company, GX Manager solves a real business problem: scaling personalized experiences across enterprise brands without the risk of human error or compliance issues. For developers, it proved that AI-driven personalization doesn’t have to be a closed system. It can be built like any other production system: modular, observable, and reliable from end to end.  

Allan Mazzocchi, Lead Product Manager at SJR, helped to design and deliver GX Manager. Even with his decade of experience building scalable cloud architectures and AI-powered web platforms, turning the GX Manager prototype into a production-ready system had unique challenges. 

For a broader look at GX Manager’s impact beyond the developer view, this story highlights how it empowers technical decision-makers to transform static websites into dynamic, personalized digital experiences. It explores the strategic benefits, enterprise governance, and scalable personalization capabilities made possible through Foundry, Content Understanding, and other Azure services.

Q: What problem were you trying to solve with GX Manager, and why did it matter?

Allan: Websites often feel static and one-size-fits-all. We wanted to personalize the experience by delivering exactly what people were looking for instantly and accurately, while also gathering intelligence that informed future interactions. The idea was to turn websites into conversion sites. 

But webpages often have a variety of media, mismatched images, and inconsistent schemas, which made personalization difficult and reduced confidence in the experience we were trying to deliver.

Content Understanding helped us automate enrichment and image matching for GX Manager, powering scalable, branded personalization. For developers, it helped automate what used to be manual and error-prone and created a system that could scale reliably. Logs and retries weren’t optional; they were our safety net.

Q: What was the makeup of the team, and what role did you play?

Allan: To start, we kept the team lean. I led system design and technical decisions, ensuring seamless Azure assimilation. Our dev team included two back-end engineers focused on pipelines and incorporating Azure. We also had a front-end engineer for the GX Manager interface, our data science team, and a business analyst for requirements and delivery alignment. 

One of our back-end engineers, Marcus Dantas, joined a few months in to help refine the enrichment pipeline, tune performance, and get Content Understanding production-ready. 

Q: How did you design the architecture and assimilate Content Understanding into your pipeline?

Allan: GX Manager’s ingestion pipeline is modular and built for scale. We start with a custom scraper running in Azure Container Apps that pulls HTML, PDFs, and images from client websites. We built asynchronous orchestration so parsing and enrichment could run in parallel and refined our schema design over time. 

Content Understanding runs in parallel with parsing. It enriches each asset with tags, key phrases, and image descriptions, turning unstructured web content into structured, searchable data. We post-process the output and tie metadata back to page context so every asset contributes meaningfully to the final experience. It helped that early on, we referred to the Content Understanding Quickstart Guide—it clarified the APIs as we got started. 

The orchestration logic is what makes this powerful. Each step adds fidelity, but it’s the way we sequence and unify them that helps ensure accuracy and trust. Off-the-shelf connectors couldn’t handle malformed HTML and embedded media, so we had to write bespoke handlers and orchestration logic to keep enrichment usable in production.   

We started with default Content Understanding templates for image and document summarization in Foundry but quickly realized we needed deeper customization. By rewriting the analyzer templates with brand-specific instructions for summaries and image descriptions, we achieved the quality lift required for production. That engineering pivot—parallel enrichment and post-processing—was the turning point from proof of concept to production-grade. 

Q: What does the user-facing experience look like once everything is running?

Allan: When a visitor asks a question, GX Manager follows a retrieval-augmented generation (RAG) workflow: retrieve, generate, and respond. Query Elasticsearch pulls top relevant text and enriched media, passes that context into a GPT model hosted in Azure OpenAI in Foundry Models, and composes a natural language answer with correct text, on-point images, and inline citations for transparency.

GX Manager’s response logic runs in Container Apps, scaling elastically. By grounding GPT outputs in our enriched index, we deliver answers that are accurate, brand-safe, and instantly verifiable. These answers are then shared with the user through a range of templates presented on the client’s site via iFrame. 

Q: What were the toughest performance constraints, and how did you design for load and reliability?

Allan: Performance was nonnegotiable. We separated ingestion from the real-time query path so background jobs never slow user queries. 

Serverless, containerized services gave us elasticity. Azure Functions and Container Apps scaled instantly during traffic spikes or large ingestion batches. We built resilience with retries, queues, and staging indexes, and scheduled lengthy tasks like image analysis off-peak to avoid bottlenecks. 

Q: What lessons did you learn as the system evolved during development and testing?

Allan: One of the biggest pivots came when we realized that enriching content after parsing stripped away too much context. For example, imagine a page showing executive headshots alongside bios. If Content Understanding analyzes the headshots in isolation, it might return something generic like “a black-and-white photo of a woman.” But when it runs in parallel with parsing and has access to the surrounding text, the output becomes far more meaningful, like “Sally Jones, CVP of Marketing for Contoso.” That contextual awareness made GX Manager more effective. 

We also learned that Content Understanding out of the box wasn’t enough; you have to post-process, filter, and refine. That’s the difference between trusting a demo and shipping production code. 

If we were doing this again, we would incorporate Content Understanding much earlier in the development cycle so that enriched image data was part of our architecture from the outset. 

Marcus: We quickly realized that AI outputs needed tuning. Content Understanding often returned overly detailed image descriptions, so we refined analyzer field descriptions—mini-prompts that guided the model toward concise, relevant outputs. Small tweaks there delivered huge gains. Logs and instrumentation were critical; they revealed parser quirks and enrichment misses long before users noticed. 

Q: How did you measure success, and what results did you see?

Allan: We measured onboarding speed, tracked error reduction after enrichment, and logged throughput on ingestion jobs. These metrics grounded our decisions and built credibility. 

We benchmarked image and fact accuracy against a ground-truth list and ran internal user tests. Our focus was on delivering fast, dependable responses, with logs in place to maintain steady and predictable results. Content Understanding, combined with system tuning, boosted image accuracy significantly, marking a clear improvement over our initial results. 

Q: What part of this project was most rewarding for you as a developer?

Allan: Turning a tedious, manual process into an automated, intelligent one. Before, content teams curated pages by hand, and developers wrote custom code for images or searches. Now much of this is handled automatically.  

Marcus: Being able to implement something people can use immediately is a great feeling. As a developer, being able to automate things is the dream.  

Q: What advice would you give to another developer building with Foundry?

Allan: Plan your data schema early. Use sandbox environments to explore AI quirks. Batch and parallelize everything. Post-process AI outputs before surfacing them. Implement logging and telemetry from day one. And start small, iterate often, and be ready to pivot.

Dig into the best practices and code samples from the Quickstart Guide early on. It really helps smooth out roadblocks and makes incorporating Foundry a lot more straightforward. And one tip from hard experience: always provide detailed field descriptions and context to guide AI outputs—this significantly improves accuracy beyond just post-processing raw results. That’s the difference between a flashy demo and a production system. 

The win wasn’t using AI—it was eliminating the grind so we could focus on what matters. 

To learn more about how SJR uses GX Manager to help companies get more value from their websites, visit the related story here: SJR modernizes websites with Foundry-powered personalization