Mid-level 3 min · March 19, 2026

AutoSys Override Trap — Active Override Overrules Permanent

Even after updating permanent start_times, a forgotten one-time override causes next run to use wrong old time.

N
Naren · Founder
Plain-English first. Then code. Then the interview question.
About
 ● Production Incident 🔎 Debug Guide
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
Plain-English First

A one-time override is like telling a taxi driver 'just for this trip, take the highway instead of the usual route' — without permanently changing the route on the GPS. The next trip, the driver goes back to the normal route.

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.jilBASH
1
2
3
4
5
6
7
8
9
10
11
12
/* 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.
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

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.shBASH
1
2
3
4
5
6
7
8
# 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.shBASH
1
2
3
4
5
6
7
8
9
10
11
12
# 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.shBASH
1
2
# 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
Treat overrides like sticky notes
  • 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.
● Production incidentPOST-MORTEMseverity: high

Silent Scheduling Shift Due to Forgotten Override

Symptom
The 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.
Assumption
The team assumed that a permanent update_job had been done, or that the previous override had expired after the first run.
Root cause
An 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.
Fix
Run 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 guideUse these symptom-action pairs to quickly determine if an active override is causing your job to misbehave.4 entries
Symptom · 01
Job runs at a different time than defined in start_times
Fix
Check autorep -J <job> -d and look for [OVERRIDE] next to start_times. If present, remove or fix the override.
Symptom · 02
Job starts despite condition not being met (e.g., dependency condition says FAILED but job ran OK)
Fix
Verify with autorep -J <job> -q if condition field has an override — empty condition string means no condition for this run.
Symptom · 03
Job runs on a different machine than expected
Fix
Check machine attribute in autorep -d output. Override may have specified an alternate host.
Symptom · 04
Job behaviour changed after a holiday or maintenance window
Fix
Run autorep -J <job> -d and look at the 'override' section. Overrides often remain from temporary changes made during maintenance.
★ Quick Override TroubleshootingIf 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 action
Check 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 now
Run 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 action
Query 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 now
Set the correct condition using override_job again, or run update_job with the correct condition to clear the override.
override_job vs update_job vs FORCE_STARTJOB
MethodChange is permanent?Affects next run?Affects future runs?Use case
update_joboverride_jobFORCE_STARTJOB

Key takeaways

1
override_job applies a temporary attribute change to the next run of a job, then expires automatically
2
The permanent job definition is unchanged
after the overridden run, everything reverts to normal
3
Use override_job for one-off changes; use update_job for permanent changes
4
Always document active overrides so your team knows why a job might behave differently
5
Check for active overrides with autorep -d before deleting or recreating jobs
6
update_job on an overridden attribute removes that specific override

Common mistakes to avoid

5 patterns
×

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 PREP · PRACTICE MODE

Interview Questions on This Topic

Q01JUNIOR
What is a JIL one-time override in AutoSys?
Q02SENIOR
What is the override_job subcommand used for?
Q03SENIOR
How does override_job differ from update_job?
Q04JUNIOR
How many times does a one-time override apply?
Q05SENIOR
How do you check if an AutoSys job has an active override?
Q01 of 05JUNIOR

What is a JIL one-time override in AutoSys?

ANSWER
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.
FAQ · 8 QUESTIONS

Frequently Asked Questions

01
What is a one-time override in AutoSys?
02
Does override_job run the job immediately?
03
How long does an override stay active?
04
Can I cancel an active override?
05
How do I see if a job has an active override?
06
Can I override multiple attributes in one command?
07
What happens if I set an override while the job is already running?
08
Do overrides affect box jobs (containers)?
🔥

That's AutoSys. Mark it forged?

3 min read · try the examples if you haven't

Previous
File Watcher Jobs in AutoSys
12 / 30 · AutoSys
Next
AutoSys Job Scheduling and Time Conditions