I Just Earned Rovo Fundamentals and Loom Fundamentals. Here's How I Use Them Daily

[Ryan]

I finished Atlassian’s Rovo Fundamentals and Loom Fundamentals certificates this weekend.

Neither one is a trophy. Both are short, free, open-book credentials that confirm something I already do every day: find the right context fast, turn it into action, and communicate without adding another meeting.

If you live in Jira and Confluence — especially as a Technical Program Manager — these two tools are no longer “nice to have.” They are how work moves when the calendar is full and the system of record is scattered across tickets, pages, Slack threads, and a dozen SaaS apps.

This is what the training covered, what the exams felt like, and how I actually use both tools in a Senior TPM workflow.

---

Why these two certificates together

Atlassian has been assembling a Teamwork Collection: Jira as the system of record, Confluence as the shared brain, Loom as the async glue, and Rovo as the AI layer that can search, chat, and act across all of it.

The new certificate program reflects that. Rovo Fundamentals and Loom Fundamentals now sit on the path toward designations like Atlassian Certified Teamwork Collection Specialist, and they also count toward Agile DevOps and ITSM specialist tracks.

That mapping matters if you already hold Jira or Confluence essentials, or if you are the person who has to make an Atlassian Cloud migration usable after the cutover — not just technically complete.

I did not take these to collect badges. I took them to tighten the loop between:

• Find the decision that already exists

• Learn why it was made

• Act without waiting for a 30-minute status call

• Explain the result in a way a stakeholder can consume on their own time

Rovo handles the first three. Loom handles the fourth.

---

What the training and exams actually felt like

Both credentials follow Atlassian’s newer certificate model: free, unproctored, open-book, and designed for people who already use the product.

Rovo Fundamentals

The recommended path is the on-demand course Get the most out of Rovo (about an hour and 45 minutes). The exam tests whether you can:

• Navigate Rovo and understand workspace context and permissions

• Search across Atlassian apps and connected third-party sources

• Use Chat to summarize, draft, and cite sources

• Work with Agents to take on bounded tasks instead of just answering questions

The most useful concept in the training is not a feature list. It is the TCREI prompt pattern:

• Task — what outcome you want

• Context — the situation, audience, and constraints

• References — the tickets, pages, or links Rovo should use

• Evaluate — check the answer against reality

• Iterate — tighten the prompt instead of accepting the first draft

That is just good delegation. If you already write decent tickets and decision records, TCREI will feel familiar. If you treat AI like a search box with extra words, the exam will expose that habit quickly.

Permissions also get real attention. Rovo does not invent access. If you cannot see a Confluence page, neither can the answer Rovo gives you. In a security-conscious environment that is a feature, not a limitation. You still have to know where knowledge lives and who is allowed to see it.

Loom Fundamentals

Loom Fundamentals replaced the older Loom Essentials cert. Same idea: free, open-book, focused on the skills you use at work rather than studio production.

The Get the most out of Loom path covers creating and sharing videos, editing, AI assists (titles, summaries, chapters, filler cleanup), and how Loom sits next to Jira and Confluence.

The exam is not asking you to become a video producer. It is asking whether you know how to:

• Record a short, purposeful update instead of scheduling a meeting

• Add enough structure that someone can skip to the part they need

• Share in the right place (ticket, page, Slack) with the right visibility

• Use the AI layer so the video is searchable and skimmable, not just watchable

If you already record walkthroughs, the training is a cleanup pass. If you still default to “let’s hop on a call,” it will make that default look expensive (engineers and stakeholders time = $$$$$$$$$$$$$$$$$$)

---

How Rovo shows up in my day

I do not open Rovo to “try AI.” I open it when the alternative is hunting.

1. Search that starts from intent, not syntax

A TPM’s first tax is context switching. “Where did we decide the cutover window?” “Which epic still owns this dependency?” “Who last touched the permissions model?”

Rovo Search is useful when the answer is not in one project. It pulls from Jira, Confluence, and connected tools and returns knowledge cards instead of a pile of links. I still verify the source. I just spend less time remembering which space, which label, and which outdated page title someone used in 2024.

2. Chat as a first draft, never a final decision

Typical prompts in my week:

• Summarize this Confluence decision page for an exec who has five minutes

• Draft a risk register update from these epics and the last two status pages

• Turn this messy thread of comments into a proposed RACI

• Explain the difference between two competing implementation options using only the linked tickets

TCREI keeps this honest. I name the audience, attach the sources, and tell Rovo what to do when evidence is missing. If it cannot cite the page or the issue, the answer does not ship.

That last rule matters in fintech and security work. Fluent language is not the same thing as an approved control.

3. Agents for repeatable, bounded work

The Fundamentals exam treats Agents as teammates you assign work to, not magic.

The pattern that holds up in a program role:

• Recurring status synthesis across a defined set of Jira spaces

• First-pass grouping of incoming requests before a human triage

• Drafting onboarding or runbook updates from a known source set

• Pulling “what changed since Friday” without building a custom dashboard every week

I do not let an agent change production work or send stakeholder comms without a review. The certificate training is explicit about keeping a human in the loop. That is also how you stay out of trouble with audit and change control.

Rovo Studio and deeper agent-building sit beyond Fundamentals. The certificate is the floor: know what Search, Chat, and Agents are for, and know when not to use them.

The more I use Rovo, the more it feels like a teammate I can depend on.

---

How Loom shows up in my day

Loom is how I protect the calendar without going silent.

1. Replace the “quick sync” that is never quick

If the goal is to show a Jira workflow, a Confluence information architecture, or a permissions path, a 3–6 minute Loom beats a 30-minute meeting. The viewer watches at 1.5x, jumps to a chapter, and comments on the exact timestamp.

I use this for:

• Walkthroughs after an Atlassian change (new board, new space, new request type)

• “Here’s why this epic is blocked” updates to a sponsor

• Demo of a process before I write the SOP, so the SOP matches reality

• Async answers to the same question I would otherwise answer live three times

• New Rovo agent demos

2. Attach video to the system of record

A Loom that lives only in Slack dies in Slack. The useful pattern is:

• Record

• Let AI generate the title, summary, and chapters

• Drop the link on the Jira work item and the Confluence page that owns the decision

• Point people at the chapter, not the whole video

That is the difference between “we made a video” and “the work now has a durable explanation.”

3. Training without building a course every time

I already publish Atlassian and agility material. Loom is the capture layer: record the click-path once, trim the dead air, ship the link. The Fundamentals material on editing, sharing settings, and AI cleanup is the difference between a usable clip and a 14-minute ramble nobody finishes.

Short is a feature. If it needs more than eight minutes, it is usually two videos or a page with a video embedded at the top.

---

Where the two tools compound

Used separately, Rovo is a faster researcher and Loom is a faster explainer. Used together, they close a loop I used to leave open:

1. Rovo finds the current state across Jira and Confluence.

2. I confirm the sources and make the call.

3. Loom records the decision and the why in the actual UI.

4. The Loom lands on the ticket and the page.

5. Next week, Rovo can find that explanation instead of only the raw tickets.

That last step is the one most teams skip. They generate AI summaries and record videos, then leave both artifacts outside the system of work. Six weeks later nobody can find either one.

The Teamwork Collection pitch is real when you treat Rovo output and Loom recordings as first-class objects in Jira and Confluence — with owners, dates, and permissions — not as side chats.

There is also a practical pairing Atlassian has been shipping: connect a Loom to a Jira space and let Rovo suggest work-item updates from the discussion. That only helps if the recording was specific. Vague video in, vague tickets out.

---

What I would tell another TPM before they sit the exams

Do the learning paths, then take the tests the same day. Both are designed around current product behavior. Cramming flashcards is the wrong move. Using the tools on a live project for a week, then sitting the open-book exam, is the right one.

Practice TCREI on real work, not toy prompts. “Summarize this page” will pass a demo. “Draft a Friday delivery update for leadership using only spaces X and Y, separate facts from inferences, and link every claim” is the prompt that changes your week.

Respect permissions. If your company is careful about data classification — and it should be — Rovo is only as good as the access model underneath it. Cleaning up Confluence restrictions and Jira scheme sprawl is still the unglamorous prerequisite.

Keep Loom short and parked next to the work. Record standing up, with a purpose sentence in the first ten seconds. If you cannot say the purpose in one sentence, you are not ready to hit record.

Do not confuse a certificate with adoption. Passing Rovo Fundamentals does not mean your org is AI-native. It means you can operate the basics without creating sloppy content or leaking context. Adoption is a program of use cases, guardrails, and measurement. The badge is just proof you can start that program without guessing the UI.

---

Why I bothered

I already use these tools. The certificates took a few focused hours, cost nothing, and gave me a clean way to talk about the practice with stakeholders who still think “Atlassian AI” means a magic comment box.

More useful than the PDF: the training forced me to name the habits that actually save time.

• Search before you Slack.

• Prompt with sources and an audience.

• Let an agent draft the recurring artifact, then review it.

• Record the walkthrough once.

• Put both the answer and the explanation back into Jira and Confluence so next week’s search works.

That is Everyday Agile in this stack: shorter feedback loops, fewer useless meetings, and a system of work that remembers what we decided.

If you are already in Cloud and you have not taken these two yet, take them. Then pick one recurring status ritual and one recurring explanation ritual and run them through Rovo and Loom for two weeks. The certificate is the easy part. The workflow change is the point.

---

I’m Ryan Key, a Principal TPM.

[kh-samyak]

@Ryan 
Thanks for your post!

We’ve removed the external links from your post, per our Community Rules of Engagement, external links that may be promotional aren’t allowed in forum posts.