One theme runs through nearly all of this: Jira told you it worked.
A form smart value writes nothing and reports success. A default value of None vanishes and takes the field's behaviour with it. sendNotifications does not suppress the notification. A filter keeps returning rows long after the field it references stopped existing. An attachment migration ships zero bytes behind an HTTP 303 that everything in the chain treats as fine.
So a good half of these are really about verification — checking that what you configured is doing what you think, usually with a query you can run yourself. Where the answer comes back as a count of zero there is normally a note on proving the query could have returned something at all. A broken query and an empty result look identical from the outside, and only one of them means you are finished.
Behaviour that is documented nowhere and differs between company-managed and team-managed projects.
What to check when a Jira rule or API call finishes without an error and the change never actually happened.
Rovo agent permissions control who can create, edit and use an agent, and the agent then acts as you or as its own account. Here's what an admin can actually set today, what gets logged, where the human in the loop sits, and how CogniRunner 6.1 agents wait for a Jira administrator before they delete anything.
Jira Cloud's API rate limit is three limits at once, and Jira gives an admin no screen that says which app spends it. This walks the headers with curl, what a 429 tells you, and CogniRunner's Maintenance screen and REST report, hour by hour and by component.
A Forge app REST API is called from outside Jira with an OAuth 2.0 (3LO) access token. This walks the whole path with curl against LeanZero Management: the admin switch, the integration and its scopes, consent with sns, the token exchange, rotating refresh tokens, and the four 403s I hit on the way.
Two new skills in LeanZero's open-source agent skills pack. automation-engineer drives the Jira automation rules API under /automation/public/ to read, create and migrate rules between Cloud sites. atlassian-cloud-to-cloud-migration-skill copies Jira projects, JSM desks and Confluence spaces into a live site over REST. How to install them, what each one has proven, and what it hasn't.
A Jira coding agent that works inside the issue: it reads your GitHub repository, plans, stages the edits, and on its default setting commits or opens a pull request only after you confirm a card, with the commit card naming every file. Walked end to end on our production build, with the pull request it opened and how to check it, and what 5.2.0 changed.
CogniRunner lets a Jira admin put OpenAI, Anthropic, Gemini, Bedrock, a self-hosted model or the zero-key Atlassian Forge LLMs behind the same workflow validator. This walks the setup end to end and says what actually changes when you bring your own key: where the data goes, who pays, which models you get, and what Runs on Atlassian has to do with it.
JCMA stops with "We couldn't export Custom Field Config Scheme" and a java.lang.NullPointerException, and the same message has three unrelated causes, each documented in a different Atlassian source. Here is how to tell them apart from the log line, the fix for each, three problems in the knowledge base's own SQL, and what the Cloud-to-Cloud side looks like.
An Atlassian data security policy has seven controls, and only one of them works without Atlassian Guard: blocking all Marketplace and custom apps from chosen spaces. This post walks through what each control blocks, what the app access rule really takes away from an app, what the admin API says when you try a Guard control without Guard, and what happens to policies and classification levels on a Data Center to Cloud or Cloud to Cloud migration.
JCMA stops a project export with "We couldn't export Issue Security Level Permission 10001. Reason: java.lang.NullPointerException. [JCMA 000]" when an issue still points at a security level that no longer exists. This tutorial finds the orphaned level and the issues that reference it, fixes them in the Jira Data Center database, checks the custom-field grants JCMA silently drops, and proves on Cloud that the right people can see the right issues. The Cloud-to-Cloud route through Copy product data is covered too.
Gabriela became an Atlassian Certified Administration Expert, passing three ACP exams in a single day — and she now holds three Atlassian designations in total. Here's the free ACP practice-exam bank that helped get her the Administration Expert one, bigger and better-tested as of today.
Jira's CSV importer always requires a populated Summary column, even when the only thing you're changing is a custom field like an Assets object. Here is what Atlassian's own docs actually say a populated Summary does on an update row, the real error message a missing issue returns, and the honest, unresolved story of the community thread this tutorial is built from — a ticket that appeared to vanish, and never had its cause confirmed.
Jira 11.3 runs on Java 21 only, ships a 2 GB heap, and the Cloud Migration Assistant needs 8 to 16 GB of it just to hold issue IDs during export. This is the DC-side preparation for a large migration: a heap calculator built from Atlassian's own tables and the GC log, the 32 to 47 GB band you must not land in, the CPU-to-thread table that sets migration speed, the database pool, the timeouts, the jobs to switch off, and what Atlassian has actually tested at 80,000 users and seven million issues.
Descriptions truncated at exactly 32,767 characters. A custom field populated into a (migrated)-suffixed twin while the one on your screen stays blank. Here is how to find both, and the four-phase discipline that stops the repair becoming the next incident.
CogniRunner lets a workflow validator read your JSON schema before it decides. There is a 30,000-character ceiling on what reaches the model, it cuts mid-string, and on the validator path nothing tells you. Here is how to attach a document, prove it changed the verdict, and measure what got dropped.
Until this release CogniRunner could only act when an issue crossed a workflow transition. 3.3.0 adds the two other ways an automation has always needed to run — react to an event, or run on a schedule — and a REST API that provisions both as JSON. Here is what each one actually does, what it refuses to do, and why the guard rails are shaped the way they are.
A migration report is written by the process that did the work, from the same assumptions. And the check you run instead has a worse failure: if your account cannot see a project, the audit returns zero and reads as good news.
The day after the five practice exams went live, the pools were cut from 2,937 questions to 2,687. Before that, on the branch, the stems had been reshaped to real-paper form, every answer key checked blind against the Atlassian page, and five wrong keys corrected. Here is what changed, with the numbers, and what keeps the service free.
Four ACPs, a gruelling two months, and an Atlassian Certified Expert badge at the end of it. The gamble was harvesting every dump site on the internet and refusing to believe a single answer until the documentation said so — and the free practice exams that came out of it now cover all five ACPs.
A JSU condition reading priority > 5 can arrive on Cloud as priority = 5. The rule is present, enabled, and green. It now guards a different thing, and nothing anywhere reports it.
A rule that relearns your instance's quirks on every run is paying for the same lesson forever. Here is how CogniRunner stores those lessons, how the byte budget keeps them from crowding out the prompt, and the two places the behaviour is not what the names suggest.
I passed the Claude Certified Architect and ACP-120 within days of each other. One of them changed how I build agentic workflows, and not for the reason I expected. Here is the honest version, and what I am building next.
A plan is built for one source-destination pair. Re-run it against another and cached IDs from tenant A land in tenant B. There is a fingerprint to stop that — and it declines to stop the plan most likely to be wrong.
A buffer task that absorbs slip until it can't, a plan that defends itself against edits made in Jira, and a write path that refuses rather than lies. Traced line by line, and set against what BigPicture and Structure.Gantt actually document.
Six reports were announced for retirement. Three were saved, three were not, and both dates in circulation have now passed in silence. Three different answers are going around and none of them come from Atlassian — here is where each one actually starts.
getJiraIssue reports worklog.total correctly and then returns twenty entries. Sum those and your monthly report is quietly short — one person measured 21%. Five steps to detect the truncation, recover the full set, and know exactly which part of your number is proven.
Atlassian publishes what each migration tool copies. Turning that page into a scope document takes six steps and one insight most people miss: some things are copied partially, and a tool that reports those as done will cost you the migration.
DC to Cloud spends its budget resolving who everyone is, because usernames do not exist in Cloud. Cloud to Cloud gives you identity for free and a first-party copy tool — then bills you for the specific things that tool does not take.
The @forge/api route template throws on two different mistakes with one identical message. Six steps to tell them apart and fix each, with a probe that prints exactly which characters it rejects in a path and which it silently encodes in a query.
The removed Jira search endpoint fails loudly with a 410. The one-line migration to /search/jql fails quietly: HTTP 200, the right number of issues, and every field null. Measured from inside a deployed Forge app.
A widely accepted community answer says sub-tasks cannot skip a hierarchy level. Atlassian's own knowledge base says the opposite. I ran it on both project types: company-managed accepts it through the REST API and through the UI, team-managed refuses it in both, and half your reports cannot see the result.
Atlassian's own workaround for suppressing comment email rides the edit-issue endpoint. I built a bed on a live Cloud tenant to test it — and found four separate ways the bed reports success without sending a single email.
For a year our workflow conditions evaluated a constant and gated nothing. 3.1.0 replaces that constant with ten checks that Jira runs itself. Here is what shipped, what I measured against a live Jira, and how it compares to what else is on the Marketplace.
JCMA brings your rules to Cloud disabled and without their actors. Cloud-to-cloud brings nothing at all. Measured on a live Cloud site: the Rule Management API's 400s that name no field, the app-actor discovery our own runbook got wrong, and the scope ARI the API silently rewrites behind your back.
Jira Cloud answers 303, Confluence answers 302, and an SSO-fronted Data Center answers with a login page. I measured the two Cloud cases end to end, and the failure that follows passes every audit you are likely to write.
A customer changes email domain and starts appearing twice in the reporter picker. Removing them from the project provably cannot fix it, the query that finds their tickets stays silent when it fails, and the reassign that clears them reports the wrong reason for refusing.
The manual Clear Done work items button is gone from team-managed boards, and company-managed boards never had it. They have something better, and I measured it: a released version empties the Done column for everyone in under 15 seconds.
We shipped both modules in CogniRunner pointing at the same handler. Only one of them ever invoked it. forge lint says No issues found, forge deploy validates the manifest and passes, and the gate you built is permanently open with zero log lines. Here is the probe app that proves it, and the two things that actually work.
A blocks link in Jira records a relationship. On Free and Standard it reschedules nothing. Here's the engine we put behind it, the required-start rule that's easy to get subtly wrong, and what it still can't do.
Jira Cloud answers a JQL query about a custom field that does not exist with HTTP 200 and a count of zero. In a post-migration field audit, zero is the number that authorises deleting the field. I swept all 197 custom fields on a live site to find out which gate actually catches it.
A saved filter is a string, not a binding. I measured what cf[10042] actually resolves to on a destination site, and where Data Center to Cloud and Cloud to Cloud each fail silently.
A rule reads a dropdown answer off a Jira form, runs clean, logs no error, and leaves the field empty. Two things are wrong and both are in the rule rather than the log. Here is the mechanism, the full field-type mapping, and the check that decides whether any of it applies to you: there are two unrelated features called Forms and only one of them automation can see.
A Community Champion added sendNotifications: false to an automation rule, re-imported it cleanly, and still got the mail. Here is why the flag is ignored, which endpoints actually carry a suppression flag, and how to tell a real API parameter from one Jira is only pretending to accept.
Your organisation uses Tempo Timesheets and needs to prevent users from logging time against certain Jira issue types — like Risk, Assumption, or any work type that exists for tracking purposes only. There's no toggle for this in Tempo. But there's a workflow property that does exactly what you need, and it takes five minutes once you know where to look.
Set a default value on a Jira Cloud single select field and "None" silently vanishes from the dropdown — with zero UI option to bring it back. Here's what's actually happening under the hood and the exact curl command that fixes it.
This comprehensive guide demonstrates how to build a robust user ingestion system that transfers users from Microsoft Graph API (Azure Entra ID) to Jira Service Management Cloud Assets. The solution handles complex scenarios without complete public API documentation by implementing custom logic for object reference attributes, user type attributes, and sophisticated error handling mechanisms.