The Safe Way to Delete Jira Custom Fields
A decision framework that prevents “oh no, we needed that”
The fear is justified. Delete the wrong field, and you might break filters that executives rely on, dashboards that drive decisions, or automation rules that keep your workflows running. Worse, you might lose historical data that someone will desperately need six months from now.
But here’s the thing: not cleaning up is also a choice with consequences. Every unnecessary field degrades performance, adds complexity, and makes your Jira instance harder to manage.
This article gives you a systematic approach to make deletion decisions with confidence.
The Decision Framework: Delete, Hide, Merge, or Keep
Before touching any field, run it through this decision tree:
START: Field identified as cleanup candidate
│
▼
Has data? ──NO──► Safe to DELETE
│ (but verify dependencies first)
YES
│
▼
Data still valuable? ──NO──► DELETE
│ (accept data loss)
YES
│
▼
Actively used? ──NO──► HIDE from screens
│ (preserve data, reduce clutter)
YES
│
▼
Duplicate of another field? ──YES──► MERGE data, then DELETE
│
NO
│
▼
KEEP (it's actually needed)
Let’s break down each option:
DELETE
When: Field has no data, or data has no business value
Result: Field removed from system, any existing data permanently lost
Reversible: No
HIDE
When: Data has historical value but field is no longer actively used
How: Remove from all screens, keep in system
Result: Field invisible to users, data preserved, no performance impact from screens
Reversible: Yes — add back to screens anytime
MERGE
When: Duplicate fields exist, both contain valuable data
How: Copy data from field A to field B, then delete field A
Result: Consolidated data in single field
Reversible: Only if you export data before merging
KEEP
When: Field is actively used and valuable
Result: No action, remove from cleanup list
Next step: Consider optimizing context (global → project-specific)
The Pre-Deletion Checklist
Before deleting ANY field — even one with zero data — verify it’s not referenced elsewhere. A field can be empty but still break things if it’s wired into your configuration.
Check 1: Saved Filters (JQL)
Users may have filters that reference your field, even if the field is empty.
SELECT sr.id, sr.filtername, sr.authorname, sr.reqcontent FROM searchrequest sr WHERE sr.reqcontent ILIKE '%customfield_10XXX%' OR sr.reqcontent ILIKE '%Your Field Name%';
Replace 10XXX with your field’s ID and Your Field Name with the actual name.
If results found: Contact filter owners before deletion. They’ll need to update their filters.
Check 2: Dashboard Gadgets
Gadgets might display or filter by your field.
SELECT pp.pagename, pc.id, gup.userprefvalue FROM gadgetuserpreference gup JOIN portletconfiguration pc ON pc.id = gup.portletconfiguration JOIN portalpage pp ON pp.id = pc.portalpage WHERE gup.userprefvalue LIKE '%customfield_10XXX%' OR gup.userprefvalue LIKE '%Your Field Name%';
If results found: Those dashboards will break or show errors after deletion.
Check 3: Screens
Where is this field displayed?
SELECT cf.cfname, fs.name as screen_name, fst.name as tab_name FROM fieldscreenlayoutitem fsli JOIN fieldscreentab fst ON fsli.fieldscreentab = fst.id JOIN fieldscreen fs ON fst.fieldscreen = fs.id JOIN customfield cf ON fsli.fieldidentifier = 'customfield_' || cf.id::text WHERE cf.id = 10XXX;
If results found: Field is on active screens. Removing the field won’t break the screen, but users might notice and ask questions.
Check 4: Workflows
This one’s tricky — fields can be referenced in:
- Conditions (“Field X must equal Y to transition”)
- Validators (“Field X is required”)
- Post-functions (“Set Field X to value Z”)
Manual check required:
- Go to Administration → Workflows
- For each workflow using projects where your field exists
- Edit workflow → check each transition’s conditions, validators, post-functions
- Search for your field name
Alternative: If you have ScriptRunner, search all scripts for the field name or ID.
Check 5: Automation Rules
Jira’s built-in automation can reference custom fields.
Manual check:
- Go to Administration → System → Automation rules (or project-level automation)
- Search for your field name in rule conditions and actions
Check 6: Recent Activity
Even if a field looks abandoned, check when it was last actually used:
"Your Field Name" IS NOT EMPTY ORDER BY updated DESC
Look at the results:
- Last update was 3 years ago? Probably safe.
- Last update was 3 weeks ago? Someone’s using it.
The Quarantine Method
Here’s the safest approach for fields you’re uncertain about — recommended by experienced administrators including Rachel Wright:
Instead of deleting immediately, quarantine the field first.
Change the field’s context from “Global” (all projects) to a single unused project:
- Go to Administration → Custom Fields
- Find your field → Configure
- Edit the context
- Change from “Global context” to specific project
- Select a project that’s archived or unused (create a “QUARANTINE” project if needed)
What happens: The field disappears from all other projects. If anyone was using it, they’ll notice and complain.
Mark your calendar. If no one reports issues for 14 days, the field is likely truly unused.
Why this works: Database queries can’t catch everything. Workflows, automation rules, external integrations — some dependencies only reveal themselves when broken. The quarantine period is your safety net.
After two weeks of silence:
- Go to Administration → Custom Fields
- Find your field
- Click the trash icon
- Confirm deletion
If someone did complain: Simply restore the original context. No data lost, no harm done.
Merging Duplicate Fields
When you have two fields with the same name and both contain data, you need to consolidate before deleting one.
Jira doesn’t have built-in merge functionality. You’ll need ScriptRunner or similar.
Using ScriptRunner’s Built-in Script
- Install ScriptRunner for Jira if not already installed
- Go to ScriptRunner → Built-in Scripts → Copy Custom Field Values
- Create a filter for issues to process:
"Source Field Name" IS NOT EMPTY
- Select source field (the one you’ll delete)
- Select destination field (the one you’ll keep)
- Test on a small filter first (e.g., single project)
- Run on full filter
- Verify data copied correctly
- Delete source field
Before Merging
- Export both fields’ data as backup
- Document which projects used which field
- Notify users that field name might behave differently
- Update any filters/dashboards to use the surviving field
What If Something Breaks?
Despite all precautions, something might go wrong. Here’s your recovery playbook:
Scenario 1: Filter Stops Working
Symptom: User reports “my filter returns zero results” or shows an error
Cause: Filter referenced the deleted field
Fix:
- Edit the filter
- Remove or replace the deleted field reference
- Save
Prevention: The searchrequest query in Check 1 should have caught this.
Scenario 2: Dashboard Gadget Errors
Symptom: Gadget shows “Configuration error” or is blank
Cause: Gadget referenced the deleted field
Fix:
- Edit the gadget
- Reconfigure without the deleted field
- Save
Scenario 3: Workflow Transition Fails
Symptom: Users can’t transition issues, get validation errors
Cause: Workflow condition, validator, or post-function referenced deleted field
Fix:
- Edit the workflow
- Find and fix/remove the field reference
- Publish workflow
Note: This is the most disruptive scenario. Always check workflows carefully before deletion.
Scenario 4: “We Actually Needed That Data”
Symptom: Someone asks for historical data from the deleted field
Cause: Business value wasn’t properly assessed
Reality check: Once deleted, the data is gone. This is why:
- The quarantine method exists
- You should export data before deletion
- You should get explicit sign-off for fields with data
Mitigation: If you exported data before deletion, you can provide CSV/Excel reports. You cannot restore the field with its data.
The Deletion Workflow Summary
For each field on your cleanup list:
Time estimate: 15-30 minutes per field for due diligence, 2-week wait, 1 minute for actual deletion.
Yes, it’s slow. That’s intentional. Rushing custom field cleanup is how you end up in incident calls at 11 PM.
Maintaining a Clean System
Cleanup isn’t a one-time project. To prevent field bloat from returning:
Governance
- Require justification for new custom fields
- Designate a field owner for each field
- Set review dates — annual audit at minimum
- Document purpose in field descriptions
Process
- Reuse before create — check existing fields first
- Project-specific contexts — avoid global by default
- Sunset criteria — define when fields should be reviewed for removal
Monitoring
- Track field count over time
- Review Instance Optimizer quarterly
- Re-run audit queries every 6 months
The Bottom Line
Deleting custom fields feels risky because the consequences of mistakes are visible and immediate. But the consequences of never cleaning up — slow searches, confused users, admin complexity — are just as real, even if they’re gradual.
The framework in this article lets you clean up with confidence:
- Decision tree tells you what action to take
- Pre-deletion checklist catches dependencies
- Quarantine method provides a safety net
- Recovery playbook handles surprises
Start with the easiest wins: fields with zero data and no dependencies. Build confidence. Then tackle the harder cases.
Your future self — and your users — will thank you for a faster, cleaner Jira instance.
🎉 Series Complete
You now have everything you need to audit and clean up your Jira custom fields:
| Part | What You Get |
|---|---|
| Part 1 | Understanding the problem + quick health check |
| Part 2 | SQL queries to identify cleanup candidates |
| Part 3 | Safe deletion process + recovery playbook |
Start your audit today. Your Jira instance is waiting to perform better.
This article is Part 3 of the “Custom Field Health Check” series for Jira Data Center administrators.
Safe deletion methodology inspired by Rachel Wright’s Jira Strategy guides and best practices shared by The Jira Guy. SQL queries validated for Jira Data Center 10+ on PostgreSQL.