Not long ago, Vantegrate recorded a Thursday masterclass on a topic Trailhead doesn't hand you. Salesforce MCP with Jira, Confluence, and Rovo is not a slide deck: it's watching the org, the documentation, and the tickets talk to each other live.
The full class is on YouTube. Juan Manuel Garrido (JuanMa) led it with Francisco Morales (Fran), Josué Mendoza (Josu), and Esteban Morales (Esti) working through the case.
The Vantegrate team said it up front. Today they're going to connect real metadata, requirements, and user stories without living in the endless Excel.
The promise is concrete. Less sloppy handcrafting, more source of truth, and a human who still validates before anything is published.
The problem isn't Salesforce: it's how requests arrive
JuanMa started with the everyday pain. The client fires off a WhatsApp, a 40-row Excel, an endless email, or a meeting where everyone takes notes and nobody consolidates.
That doesn't scale. It stays handcrafted, it stays sloppy, and a month later nobody remembers what was decided or why.
Fran and Josu live this on large projects. The way out isn't another loose Google Doc: it's organizing actionable items and documentation in a place the team actually checks.
In this way of working, Jira holds what's actionable and Confluence keeps the real documentation. Two pieces, one cloud, bidirectional visibility.
Atlassian, the "Salesforce" of people who build software
JuanMa gave an opinion (and flagged it as one). What Salesforce is to the enterprise and mid-enterprise market, Atlassian is to those who build software and functionality.
Some people get by with Trello. Others invent a custom object for tickets inside the org.
Top-tier companies, in practice, end up on Jira + Confluence. Atlassian has a big suite (Bitbucket for those replacing GitHub, and more).
In the class they focused on three. Jira, Confluence, and Rovo.
Josu said he recently wrapped up a project with Jira. Rovo saved his skin when nobody remembered why a development had certain conditions.
Esti said he already uses Jira in two out of three projects. He hadn't touched Rovo yet, and he's curious.
Fran is warming up to Confluence and to the MCP from Claude. The map isn't theoretical: it's the stack that already shows up at serious clients.
In resources and in Pulse you'll find the material from these classes. Here the focus is the full cycle, not an isolated ticket tutorial.
Confluence: the wiki that replaces the endless Excel
Confluence is easy to understand if you think of it as an internal website. Trees, pages, spaces, and a version history like code.
That's where the what and the why live. Requirements, decisions, data dictionaries, and the documentation that should replace any Word file lost in an email.
Search runs within a space or across spaces. Content in Markdown comes in clean: Confluence converts it into rich text.
Josu asked whether it supports MD. The answer was yes, and more: you can ask Claude or ChatGPT to take the material and publish it as a page.
There's a security gem that Fran underlined. A page can be made public (indexable, with a link) or stay private, Salesforce style.
Never leave keys, passwords, or implementation secrets in Confluence (or in GitHub). That's documentation security: the wiki helps, carelessness doesn't.
Jira: who does what, and by when
If Confluence is the written truth, Jira is the execution board. Epics, user stories, bugs, tasks, and sprints.
A board is a Kanban-style board. Cards are assigned to the team (in Scrum, to the Scrum team), and the work is organized in periods: the sprint.
Epics are big groupings of functionality. Inside live items: a user story, a bug, a small task.
JuanMa added a lesser-known type: the Spike. It's research.
Example from the class: integrating Salesforce with SAP when it doesn't go through MuleSoft. You have to study the path before committing the delivery.
For small projects, the advice was clear. Pick a Team-managed project; Company-managed is for when the company already needs heavier governance.
Jira and Confluence talk to each other because they live in the same cloud. An Epic documented in Confluence can break down into stories in Jira without copy-pasting by hand again.
What Salesforce MCP is (and what it isn't)
Before the demo, Fran eased the fear. The MCP (Model Context Protocol) is not something proprietary to Salesforce.
It's an agent communication standard. It tells the agent which tools and skills it has if it uses that MCP.
If Jira publishes its MCP, the agent can create a bug, assign it, and comment. If Salesforce publishes its own, the agent can read metadata from the org and operate on that context.
JuanMa separated it from Claudeforce. Claudeforce is another story (more end-user facing); the MCP works against any client that supports it (Claude, ChatGPT, and whatever comes next).
For the Salesforce developers team, that changes the pace. They stop opening Object Manager field by field for every design question.
Live demo: Claude reads the org without opening Setup
JuanMa opened Claude (Max plan, with the high cost Fran also acknowledges) and connected the Salesforce MCP to a real org.
The request was simple and powerful. Give me the structure of the fixed asset object.
No Setup, no Object Manager. Claude fired queries at the org and returned the structure.
Then it asked about relationships with other objects and the list of fields. It's not instant: they're attached to a real org, with query latency.
The model (in the recording, one of Anthropic's most powerful) takes a lot of turns. With a more compact model, the same flow is faster.
Josu mentioned there is another masterclass that covers how to connect Claude to the MCP. Here the focus was on using it: metadata, documentation and requirements.
The business case was controlling the retirement of fixed assets. When they sell or donate one, people change the status and that's it.
Nobody enters the retirement date. Accounting doesn't know the month, the asset stays assigned to an employee who no longer has it, and sometimes they sell below book value without finding out until close.
In the org, status, acquisition date and employee assignment already existed. What had to be built: fields for retirement reason, sale value and result, plus validation rules and a Flow.
That's the kind of request that used to end up in a Word document. This time it went to live metadata.
Rovo: Atlassian's Agentforce (Studio included)
Rovo is Atlassian's AI. JuanMa said it plainly: it's the Agentforce (or the Claude, or the ChatGPT) of the Jira/Confluence ecosystem.
It has its own home. The knowledge of the projects, Jira and Confluence that you can see is already built in.
Jira spaces are the base of items (one project per company or per initiative). Confluence spaces are thought of as sites: private by default, with access control, and pieces that can be published to the internet if needed.
Rovo also has something similar to Agentforce Builder: Studio, where you create agents, automations and more. It's not just chat.
A daily-use tip. If a user story is messy, ask Rovo to clean it up.
It works. But the "pro" version of the class was something else: using Rovo from Claude (with a connector), not only from Atlassian's web app.
Adrián asked in the chat what the difference is. From Atlassian, Rovo sees the Atlassian world.
From Claude with the connectors, you combine three sources: Rovo/Atlassian, the Salesforce MCP with the org's metadata, and the context Claude already has about you, your company and your projects.
One conversation. Three brains aligned.
That's what "blows your mind", as JuanMa put it. On Atlassian pricing, the class was explicit: the structure is nothing like Salesforce's.
It's much more accessible, there are bundles, and there is a free tier. Marisa pointed it out in the chat and JuanMa confirmed it.
The full cycle: from natural language to Sprint
The map they drew is the one worth remembering.
The customer asks in natural language. The AI explores the org through the Salesforce MCP and publishes the requirement in Confluence (via the Atlassian MCP).
The AI generates the Epic and the stories in Jira. The human team implements in Salesforce.
Rovo queries, summarizes and audits. That is the closed loop.
Without this approach, the old path is still Object Manager field by field, a Word file by email, copying it into Confluence, creating stories by hand, and in the end nobody remembers the decision. That can eat up hours (or more) per request.
Fran brought a real case (an oil and gas company, no names). With Claude, meeting notes and API mockups, they built an integration dictionary and a functional flow in Confluence.
They found inconsistencies. They resolved in two meetings what in a traditional project would have taken one or two weeks of back and forth.
That's not marketing magic. It's speed with org context on the table.
Three MCPs at once: metadata → Confluence page
Live, JuanMa created a Masterclass folder in Confluence, copied the space URL and asked Claude for an instructive page on the data model.
The request had two audiences. A business user and a developer both had to be able to understand it.
That's where the three layers worked together. Claude with the conversation context, the Salesforce MCP pulling metadata in real time, and the Atlassian MCP creating the page.
Create, modify, update, delete. Every page with history.
When they opened the result, the fixed asset model appeared linked to area, location, brand, employee assignment and more relationships. Tables, charts, explanation: the kind of documentation that used to be a slog by hand.
Josu insisted on the brake. Human in the loop: always review before you deliver.
If you miss an obvious detail, you lose credibility for the entire document (and sometimes for your career). Fran added the risk of carry-over.
If you document an automation badly, whoever picks up that data later automates the error. Human comments inside Atlassian add value that AI alone doesn't replace.
There was a healthy debate. Fran, at another point, had asked why document everything if AI regenerates it instantly.
JuanMa defended human validation. Correct, comment, leave a trail.
The subtle prompt trick mattered too. Asking for two audiences changed the output: business language on one side, more technical detail on the other, on the same page.
Then they threw out a bigger contextual request (not run in full because of time). Document fixed assets across three record types (vehicles and rolling stock, office supplies, workshop tools).
Claude asked for permission and started drafting requirements. The method was clear: back-and-forth until the document ends up the way you need it, not set in stone on the first try.
If AI does all this, what are you there for?
The philosophical close of the class, without romanticism. If Claude built the model and the requirement, why do the consultant, the admin and the developer exist?
The answer was operational. Someone connected the right org.
Someone phrased the request precisely. Someone checked that the proposal makes business sense.
Someone chose which open questions matter.
That someone is you. What changes is the mix of your time: you stop spending most of it on dreadful documentation tasks and gain capacity to think and add value.
Esti went further with roles. Functional analyst, PM, developer, tester: the boundaries were blurring.
With this stack, one person can cover more of the end-to-end. The industry is heading that way, whether you like it or not.
Vantegrate is a partner of Salesforce and Oracle. In the same class they showed, in passing, products that live both inside and outside the org.
Sellium, Revio, Metrix, Trazzo and Arconte. Fran summed up Metrix as the layer that unifies sources (Salesforce, SAP, in-house developments) and lets you query them in conversation.
It resembles what Agentforce Coworker does, with the difference that it crosses more worlds of data. If you are building AI agents on Salesforce, this pattern (MCP + living documentation + auditable tickets) is the scaffolding that consultancies take for granted and almost nobody teaches in public.
These Thursday masterclasses stay on Pulse. If you want to bring the cycle into your org (MCP, Confluence as the source of truth, a clean Jira and Rovo auditing), request a demo.
The class did not get through all 47 slides. It got through what matters: real metadata, a page that a human reviews, and the path from WhatsApp to Epic without losing judgment.
That is MCP with Jira, Confluence and Rovo. The rest is more Excel copy-pasting.
