JIL One-Time Job Overrides in AutoSys — Temporary Job Changes
- override_job applies a temporary attribute change to the next run of a job, then expires automatically
- The permanent job definition is unchanged — after the overridden run, everything reverts to normal
- Use override_job for one-off changes; use update_job for permanent changes
- One-time overrides change job attributes for the next run only, then expire
- Use override_job in JIL to set temporary values for start_times, machine, condition, etc.
- The permanent job definition remains untouched — no manual rollback needed
- Overrides persist until the job runs once, even if the scheduled time is days away
- Production risk: an active override can go unnoticed and cause confusion when a job behaves differently than expected
- Always audit active overrides with autorep -J
-d before making investigations
Quick Override Troubleshooting
Job runs at wrong time or with wrong parameters
autorep -J <job> -d | grep -i overrideautorep -J <job> -q | grep -A 2 'override_job'Job seems to have no condition when it should
autorep -J <job> -qLook for 'condition:' in the output; if blank and behind an override header, the condition was overridden to empty.Production Incident
override_job: nightly_etl with start_times: "02:00" to replace the override with the correct value, or use update_job to set the permanent value and then delete the override by running override_job with empty attributes (not officially supported — safest is to reapply the correct override). Alternatively, use autorep -J nightly_etl -q to see the override, then issue update_job on the same attributes to permanently change them and the override will be removed.Production Debug GuideUse these symptom-action pairs to quickly determine if an active override is causing your job to misbehave.
autorep -J <job> -d and look for [OVERRIDE] next to start_times. If present, remove or fix the override.autorep -J <job> -q if condition field has an override — empty condition string means no condition for this run.autorep -J <job> -d and look at the 'override' section. Overrides often remain from temporary changes made during maintenance.Sometimes you need to run a job differently for just one execution — a different start time, a different machine, a different command argument — without changing the permanent job definition. That's what one-time overrides are for.
This is a genuinely useful feature that many AutoSys users don't know about. Instead of updating the job, running it, then updating it back, you use override_job to specify the temporary change and it applies only to the next run.
How override_job works
override_job creates a temporary set of attribute changes that apply to the next execution of a job, then expire automatically after that run. The permanent job definition is unchanged. The override is stored in AutoSys's Event Server as a separate record keyed by job name. It's conceptually like a sticky note — attached until the job runs once, then discarded.
You can override any attribute that is normally set with insert_job or update_job: start_times, condition, machine, command, owner, etc. Multiple attributes can be overridden in one override_job statement by listing them each on a new line after the override_job: directive.
/* Normal definition: runs at 02:00 daily */ /* override_job: run it at 03:30 just this once */ override_job: daily_report start_times: "03:30" /* Override: run on a different machine for next run only */ override_job: etl_extract machine: etl-server-backup /* Override: temporarily skip a condition for next run */ override_job: generate_summary condition: /* empty condition = no condition for this run */
Override active for next run only. Permanent definition unchanged. */
Viewing active overrides
You can see what overrides are currently active using autorep. This is important to check when a job behaves unexpectedly — it might have an active override you didn't know about. The -d (detail) flag shows overrides separately from base values, while -q (JIL query) shows the full effective JIL including any overrides merged in.
# See all attributes of a job including any active overrides autorep -J daily_report -d # The -d flag shows 'override' values separately from base values # Look for lines marked with [OVERRIDE] in the output # Check the JIL including overrides autorep -J daily_report -q
start_times: 02:00 [OVERRIDE: 03:30 — active for next run]
machine: report-server-01
owner: reportuser
When to use overrides vs permanent updates
- You're making a temporary change for one specific run (e.g., running at a different time due to system maintenance)
- You need to test a different machine without changing the production definition
- You want to skip a dependency condition for a one-off catch-up run
- The change is permanent or semi-permanent — use update_job instead
- You need to change the change more than 24-48 hours before the job runs — overrides can be confusing if they sit around for days
Cancelling an active override
There is no direct 'cancel override' command. To remove an active override, you have two options:
- Run update_job on the same attributes that were overridden. update_job will overwrite the override value and reset the attribute to its new permanent value. The override record is then removed.
- Run override_job again with the original permanent values. This creates a new override that cancels the effect of the previous one. After the next run, both overrides are consumed.
Option 1 is cleaner and recommended. Option 2 can lead to a chain of overrides that becomes hard to track.
You cannot simply delete an override record via JIL — it's not a separate object. It's attached to the job until the job runs or is updated.
# Option 1: Use update_job to replace the overridden attribute permanently update_job: daily_report start_times: "02:00" # This will also remove the active override for start_times # After this, the job will use 02:00 permanently. # Option 2: Override with the original value (if you want to keep the permanent as-is) override_job: daily_report start_times: "02:00" # Now the override matches the permanent — both are 02:00. # After next run, override expires and permanent value is still 02:00.
Job: daily_report updated successfully.
Override for start_times removed.
/* Option 2 output */
Override inserted for daily_report: start_times = 02:00
Best practices and common pitfalls
Centralise override documentation — every override should be logged in a shared channel or incident tracker. This prevents the 'mysterious behaviour' scenario.
Set a TTL reminder: if you set an override more than a day before the job runs, set a calendar reminder to verify it's still needed.
Avoid overriding condition unless you fully understand the dependency chain. An empty condition can cause a job to run out of order and break downstream processes.
Use a script to list all active overrides across your environment periodically (autorep -J ALL -d | grep OVERRIDE). This catches forgotten overrides before they cause issues.
# List all jobs with active overrides autorep -J ALL -d | grep -B5 "OVERRIDE" | grep "Job Name" | awk '{print $NF}'
payment_batch
report_generator
- Override = temporary note attached to the job
- It's visible only if you look specifically (-d flag)
- It gets thrown away after the job runs once
- Multiple sticky notes (overrides) stack — only the latest matters per attribute
- If you move the job (delete/recreate), the note may still be on the desk
| Method | Change is permanent? | Affects next run? | Affects future runs? | Use case |
|---|---|---|---|---|
| update_job | override_job | FORCE_STARTJOB |
🎯 Key Takeaways
- override_job applies a temporary attribute change to the next run of a job, then expires automatically
- The permanent job definition is unchanged — after the overridden run, everything reverts to normal
- Use override_job for one-off changes; use update_job for permanent changes
- Always document active overrides so your team knows why a job might behave differently
- Check for active overrides with autorep -d before deleting or recreating jobs
- update_job on an overridden attribute removes that specific override
⚠ Common Mistakes to Avoid
Interview Questions on This Topic
- QWhat is a JIL one-time override in AutoSys?JuniorReveal
- QWhat is the override_job subcommand used for?Mid-levelReveal
- QHow does override_job differ from update_job?Mid-levelReveal
- QHow many times does a one-time override apply?JuniorReveal
- QHow do you check if an AutoSys job has an active override?Mid-levelReveal
Frequently Asked Questions
What is a one-time override in AutoSys?
A one-time override lets you change specific attributes of a job for its next execution only. After that run, the job reverts to its permanent definition. Use the override_job JIL subcommand to set one.
Does override_job run the job immediately?
No. override_job only modifies the attributes for the next scheduled run. The job still runs according to its normal start conditions unless you also send a FORCE_STARTJOB event.
How long does an override stay active?
An override stays active until the job runs once (success or failure), then it expires automatically. If the job's next scheduled run hasn't happened yet, the override remains active until that run occurs.
Can I cancel an active override?
Effectively yes. The recommended way is to run update_job on the same attributes that were overridden. This clears the override and sets the permanent value. You cannot delete an override record directly; it's attached to the job.
How do I see if a job has an active override?
Run autorep -J jobname -d which shows detailed job attributes. Active overrides are displayed separately from the base definition. You can also use autorep -J jobname -q to see the JIL including any override settings.
Can I override multiple attributes in one command?
Yes. After the override_job: <jobname> line, list each attribute on its own line. For example: override_job: myjob start_times: "04:00" machine: backup-server condition: All three overrides apply to the next run.
What happens if I set an override while the job is already running?
The override will apply to the next run after the current one completes. It does not affect the currently executing instance. The current instance continues with the original definition.
Do overrides affect box jobs (containers)?
Yes. If you override a box job's attributes, that override applies to the next box run. Note that box jobs do not run themselves — they manage contained jobs. Overriding a box's condition or start_time affects when the box becomes eligible to run its contained jobs.
Developer and founder of TheCodeForge. I built this site because I was tired of tutorials that explain what to type without explaining why it works. Every article here is written to make concepts actually click.