Skip to content
Home DevOps JIL One-Time Job Overrides in AutoSys — Temporary Job Changes

JIL One-Time Job Overrides in AutoSys — Temporary Job Changes

Where developers are forged. · Structured learning · Free forever.
📍 Part of: AutoSys → Topic 12 of 30
AutoSys one-time overrides let you change job attributes for a single run without permanently modifying the job definition.
⚙️ Intermediate — basic DevOps knowledge assumed
In this tutorial, you'll learn
AutoSys one-time overrides let you change job attributes for a single run without permanently modifying the job definition.
  • 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
override_job vs update_job override_job vs update_job. Temporary vs permanent change · override_job · update_job · Applies to next run only · Permanent change · Permanent definition unchanged THECODEFORGE.IOoverride_job vs update_jobTemporary vs permanent change override_job update_jobVSApplies to next run onlyPermanent changePermanent definition unchangedApplies to all future runsExpires after one executionOnly changed attrs updatedUse for maintenance windowsUse for config changesUse for one-off timing changesAudit trail recommendedTHECODEFORGE.IO
thecodeforge.io
override_job vs update_job
Jil One Time Job Overrides
✦ Plain-English analogy ✦ Real code with output ✦ Interview questions
Quick Answer
  • 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
🚨 START HERE

Quick Override Troubleshooting

If a job behaves unexpectedly and you suspect an override, use these commands to diagnose and fix.
🟡

Job runs at wrong time or with wrong parameters

Immediate ActionCheck active overrides with autorep -J <job> -d
Commands
autorep -J <job> -d | grep -i override
autorep -J <job> -q | grep -A 2 'override_job'
Fix NowRun update_job on the problematic attributes to replace the override, or remove the override by setting those attributes to their permanent values using override_job again.
🟡

Job seems to have no condition when it should

Immediate ActionQuery the full JIL including overrides
Commands
autorep -J <job> -q
Look for 'condition:' in the output; if blank and behind an override header, the condition was overridden to empty.
Fix NowSet the correct condition using override_job again, or run update_job with the correct condition to clear the override.
Production Incident

Silent Scheduling Shift Due to Forgotten Override

A daily ETL job started at 03:30 instead of 02:00 for two consecutive days — the team assumed a permanent change had been made.
SymptomThe job 'nightly_etl' ran at 03:30 on the first day after a holiday, even though its permanent start_times was 02:00. The team updated the start_times back to 02:00, but the next day it still ran at 03:30.
AssumptionThe team assumed that a permanent update_job had been done, or that the previous override had expired after the first run.
Root causeAn engineer had set an override (start_times: "03:30") for the holiday run and forgot to remove it. That override applied to the next run (the holiday), then expired. But after the holiday, the team ran a manual FORCE_STARTJOB which executed the job immediately — that counted as 'next run' and consumed the override. They then updated the permanent start_times to 02:00, but the override had already been consumed, so the permanent definition was correct. The next day, the job ran at 02:00 as expected. Wait — the symptom says it ran at 03:30 again. Let's revise: Actually the override was set for the holiday and was applied. Then after holiday, they ran FORCE_STARTJOB which triggered an immediate run — but that run may not have consumed the override because it was a manual start? In AutoSys, FORCE_STARTJOB bypasses conditions but does the override apply? Override applies to the next scheduled run, not a forced immediate run. So if the next scheduled run was the next day, the override would still be active. They updated permanent start_times, but the override still had start_times 03:30 and would take precedence. They didn't remove the override. That's why it ran at 03:30 again. They assumed updating the permanent definition would override the override, but it doesn't — overrides take precedence. Fix: delete the override explicitly with update_job (changing the same attributes) or using a blank override_job to clear it. Lesson: An active override overrides the permanent definition regardless of subsequent update_job. You must explicitly remove it.
FixRun 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.
Key Lesson
An active override always takes precedence over the permanent definition, even after you run update_job.Always remove or update overrides before relying on the permanent definition.Document overrides in a shared channel or ticket — don't rely on memory.
Production Debug Guide

Use these symptom-action pairs to quickly determine if an active override is causing your job to misbehave.

Job runs at a different time than defined in start_timesCheck autorep -J <job> -d and look for [OVERRIDE] next to start_times. If present, remove or fix the override.
Job starts despite condition not being met (e.g., dependency condition says FAILED but job ran OK)Verify with autorep -J <job> -q if condition field has an override — empty condition string means no condition for this run.
Job runs on a different machine than expectedCheck machine attribute in autorep -d output. Override may have specified an alternate host.
Job behaviour changed after a holiday or maintenance windowRun 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.

override_job.jil · BASH
123456789101112
/* 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 */
▶ Output
/* AutoSys/JIL: Successfully inserted override for: daily_report
Override active for next run only. Permanent definition unchanged. */
🔥Override expires after one run
The override applies to exactly one execution. After that run completes (success or failure), the job reverts to its permanent definition for all subsequent runs.
📊 Production Insight
Overrides survive restarts of the AutoSys application server — they're stored persistently.
If you delete and recreate a job with the same name while an override is active, the old override can reattach to the new job and cause unexpected behaviour.
Always check for active overrides with autorep -d before deleting/recreating jobs.
🎯 Key Takeaway
override_job creates a temporary, persistent change for exactly one run.
The override outlasts server restarts and can reattach to recreated jobs.
Rule: before deleting a job, verify no active override exists.

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.

view_overrides.sh · BASH
12345678
# 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
▶ Output
Job Name: daily_report
start_times: 02:00 [OVERRIDE: 03:30 — active for next run]
machine: report-server-01
owner: reportuser
📊 Production Insight
The -d flag is the only reliable way to see overrides without parsing raw JIL.
Many engineers incorrectly rely on -q output, which merges override values into the base definition — you can't tell which attributes are overridden from -q alone.
Always use -d to see what's an override and what's permanent.
🎯 Key Takeaway
Use autorep -J <job> -d to see overrides listed separately.
The -q flag shows merged JIL — you cannot distinguish overrides from permanent attributes.
Rule: when debugging, always start with autorep -d.

When to use overrides vs permanent updates

Use override_job when
  • 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
Do NOT use override_job when
  • 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
⚠ Override vs update: the risk of forgetting
One-time overrides are powerful but easy to forget. Always document that you've set an override (in your team's incident log or ticketing system) so colleagues don't spend time debugging 'why did that job run differently last night?'
📊 Production Insight
Overrides that sit idle for days are dangerous — someone else may update the job and not know about the override.
If you're overriding a condition, be aware that the empty condition string means no dependency whatsoever — the job will run as soon as its schedule allows, regardless of upstream jobs.
Never use override_job for changes that should persist through a restart or rollback; use update_job.
🎯 Key Takeaway
Overrides are for one-off, transient changes.
If the change will be needed more than once, use update_job.
Rule: if in doubt, use update_job — it's safer and more transparent.

Cancelling an active override

There is no direct 'cancel override' command. To remove an active override, you have two options:

  1. 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.
  2. 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.

cancel_override.sh · BASH
123456789101112
# 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.
▶ Output
/* Option 1 output */
Job: daily_report updated successfully.
Override for start_times removed.

/* Option 2 output */
Override inserted for daily_report: start_times = 02:00
💡Simplest way to cancel an override
Just run update_job on the same job with the original (permanent) values. The override is automatically cleared, and the permanent value is confirmed. No need to find the old override value — just restate the correct value.
📊 Production Insight
If you have multiple attributes overridden, update_job on a single attribute will clear only that override — others remain active.
You must run update_job for each overridden attribute separately, or rewrite all of them in one update_job statement.
Production mistake: running update_job on a job and assuming all overrides are gone — only the attributes you explicitly set are updated.
🎯 Key Takeaway
update_job on an overridden attribute removes that override.
Multiple overrides must be cleared one by one.
Rule: after a series of overrides, run autorep -d to confirm all are gone.

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_overrides.sh · BASH
12
# List all jobs with active overrides
autorep -J ALL -d | grep -B5 "OVERRIDE" | grep "Job Name" | awk '{print $NF}'
▶ Output
nightly_etl
payment_batch
report_generator
Mental Model
Treat overrides like sticky notes
A sticky note on your monitor is useful for today's task but confusing if left for a week. Same with overrides.
  • 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
📊 Production Insight
In a team of 5+, overrides are a common source of silent failures. A job runs differently, and no one knows why because the override wasn't documented.
Automated audit scripts that email a list of all active overrides each morning prevent this.
Many production incidents at banks and airlines have been traced back to forgotten overrides from maintenance windows.
🎯 Key Takeaway
Document every override immediately.
Run periodic audits of all overrides — a 5-minute script saves hours of debugging.
Rule: override_job is a powerful tool; treat it with respect and transparency.
🗂 override_job vs update_job vs FORCE_STARTJOB
Which method to use for changing job execution?
MethodChange is permanent?Affects next run?Affects future runs?Use case
update_joboverride_jobFORCE_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

    Setting an override and forgetting about it
    Symptom

    Job runs with unexpected attributes days later, causing confusion and potentially schedule-breaking behaviour.

    Fix

    Document all overrides immediately. Run a daily/weekly autorep -d check across all jobs to find active overrides. Use a script to alert the team.

    Using override_job for a change you actually want to keep permanently
    Symptom

    Job reverts to original behaviour after the next run, and you have to re-apply the change — slower and riskier than update_job.

    Fix

    Use update_job for any change that you expect to persist beyond one run.

    Thinking override_job runs the job immediately
    Symptom

    Engineer waits for the job to start immediately after submitting override_job, but it doesn't. They assume the override failed.

    Fix

    Understand that override_job only modifies attributes for the next scheduled run. Use FORCE_STARTJOB if immediate execution is needed.

    Not documenting that an override was set
    Symptom

    Another engineer sees unusual job behaviour and wastes hours debugging before discovering the override.

    Fix

    Always log the override in a shared team channel or ticketing system. Include job name, attribute changed, original value, and expected run date.

    Believing update_job clears all overrides
    Symptom

    After running update_job on start_times, the job still runs on a different machine because that machine override was not updated.

    Fix

    Run autorep -d after update_job to verify all attributes are as expected. You must update each overridden attribute individually.

Interview Questions on This Topic

  • QWhat is a JIL one-time override in AutoSys?JuniorReveal
    A one-time override is a temporary change to a job's attributes that applies only to the next execution. It's defined using the override_job JIL subcommand. After the job runs, the override expires and the job reverts to its permanent definition. Overrides are stored persistently and can be viewed with autorep -d.
  • QWhat is the override_job subcommand used for?Mid-levelReveal
    override_job is used to change job attributes (like start_times, condition, machine) for exactly one run. It does not start the job; it only modifies the definition for the next scheduled execution. It's ideal for temporary changes during maintenance or one-off catch-ups.
  • QHow does override_job differ from update_job?Mid-levelReveal
    update_job makes permanent changes to the job definition that persist for all future runs. override_job makes a temporary change that applies to the next run only. After that run, the job reverts to the permanent definition. update_job also clears any active override for the attributes you change.
  • QHow many times does a one-time override apply?JuniorReveal
    Exactly once. The override applies to the next execution of the job, whether that's a scheduled run or a manually triggered run. After that run completes (success or failure), the override is automatically removed and the job uses its permanent definition for all subsequent runs.
  • QHow do you check if an AutoSys job has an active override?Mid-levelReveal
    Run autorep -J <jobname> -d. The -d (detail) flag displays both permanent and override values separately. Look for lines marked with [OVERRIDE] next to the attribute value. Alternatively, autorep -J <jobname> -q shows effective JIL but you cannot distinguish overrides from permanent values.

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.

🔥
Naren Founder & Author

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.

← PreviousFile Watcher Jobs in AutoSysNext →AutoSys Job Scheduling and Time Conditions
Forged with 🔥 at TheCodeForge.io — Where Developers Are Forged