Past Simple for Finished Changes and Incidents

By the end of this lesson, you will be able to...

• choose past simple when a technical action is finished.

• write a short incident sentence with a clear time anchor.

• separate finished events from current state and live work.

Idea in one sentence: Past simple is the cleanest form when the reader needs to know that an engineering event happened and is now finished.

Core Insight

In the previous review, you practiced present forms:

Checkout is slow.
The dashboard shows a spike in errors.
We are investigating the queue.

Those sentences are about now: current condition, current evidence, or live work.

But incident updates also need finished events:

We deployed the fix at 09:30.
The worker restarted after the deploy.
Latency returned to normal.

These sentences use past simple.

Past simple does one important job in technical English: it places a finished event on the timeline. It tells the reader, "This happened. It is not still happening as an action."

That is useful during incidents, deploys, debugging sessions, pull request comments, and status reports. The reader can see the sequence instead of guessing it.

The Small Situation

Imagine this incident channel at 09:40:

Checkout is slow. We are investigating the queue.

At 09:45, the team finds a bad config value. At 09:50, they roll back the deploy. At 09:55, error rate returns to normal.

If the update still says only this:

We are investigating the queue.

the reader has a problem.

They cannot tell what already happened. They may think the team is still looking for the cause. They may wait instead of testing checkout again.

Past simple fixes that problem:

We found a bad config value at 09:45.
We rolled back the deploy at 09:50.
Error rate returned to normal at 09:55.

Now the finished events are visible.

The update can still include present forms:

Checkout is healthy now. We found a bad config value at 09:45. We rolled back the deploy at 09:50. We are watching the queue for delayed jobs.

That update has three time frames:

• current state: Checkout is healthy now.
• finished events: We found... and We rolled back...
• live work: We are watching...

The reader does not need to guess which actions are complete.

Plain to Precise

Plain meaning:

Use past simple when the action is finished and you are placing it in the past.

In this scenario:

The rollback happened at 09:50. The team is not still rolling back. The rollback is now a completed event in the incident timeline.

Technical name:

This is the past simple form:

subject + past verb

Examples:

We deployed the fix.
The worker restarted.
The migration failed.
The alert cleared.
Latency dropped.

For many common technical verbs, the past form ends in -ed:

deploy -> deployed
restart -> restarted
clear -> cleared
roll back -> rolled back

Some common verbs are irregular:

find -> found
run -> ran
write -> wrote
send -> sent
go -> went

You do not need to explain the grammar name in a status update. You need to use the form so the timeline is clear.

The Naive Idea

A common naive idea is:

If the incident is current, all sentences should use present forms.

That feels reasonable. The incident is happening now. The channel is active now. The reader needs current information now.

But the incident contains smaller events. Some are still true now. Some are happening now. Some already finished.

Compare these sentences:

We are investigating the queue.
We investigated the queue.

The first sentence says the investigation is live.

The second sentence says the investigation happened and is complete, or at least complete enough to report as a finished action.

If you choose the wrong form, the reader may make the wrong coordination decision.

A Worked Timeline

Start with this raw note from an engineer:

checkout slow / config bad / rollback 09:50 / errors normal / watching queue

The note has useful facts, but it is not yet a clear update.

Step 1: decide the job of each piece.

Step 2: write one sentence per job.

Checkout is healthy now.
We found a bad config value.
We rolled back the deploy at 09:50.
Error rate is normal.
We are watching the queue for delayed jobs.

Step 3: order the update for the reader.

Checkout is healthy now. We found a bad config value and rolled back the deploy at 09:50. Error rate is normal. We are watching the queue for delayed jobs.

The past simple verbs make the completed events visible:

found
rolled back

The present forms make the current situation visible:

is healthy
is normal
are watching

Naive failure contrast:

Checkout is healthy now. We are finding a bad config value and rolling back the deploy. Error rate is normal.

That version sounds like the team is still discovering the cause and still rolling back. It creates false motion. The finished work should not stay alive in the grammar.

Time Anchors Make Past Simple Stronger

Past simple often becomes clearer when you add a time anchor.

We deployed the fix at 09:30.
The worker restarted after the deploy.
The alert cleared five minutes later.

A time anchor can be exact:

at 09:30
on Tuesday
in the last release

It can also be relative to another event:

after the deploy
before the rollback
when the node restarted

The anchor helps the reader build a timeline.

Be careful with vague anchors:

recently
earlier
before

They can be useful in conversation, but they are weak in incident reports. During production work, exact or relative-to-event time is usually better:

We restarted the worker at 10:05.
We restarted the worker after the queue drained.

A Small Verb Map

Past simple becomes easier when you know the common engineering verbs that appear in incident timelines.

Use action verbs for work the team did:

Use system verbs for things the system did:

Use discovery verbs for what the team learned:

This map gives you a practical shortcut. First choose the actor:

team -> We rolled back the deploy.
system -> The alert cleared.
evidence -> We found a bad config value.

Then choose the time anchor:

at 09:50
after the deploy
when the node restarted

Then check whether the sentence needs a current result:

We rolled back the deploy at 09:50. Error rate is normal now.

That last check matters because past simple tells the reader what happened, not everything the reader needs to know next.

Where It Breaks

Past simple is not the right form for every past-looking idea.

Use present simple for a current fact:

The API owns the order state.

Do not write:

The API owned the order state.

unless ownership changed or you are describing an old design.

Use present continuous for live work:

We are checking delayed jobs.

Do not write:

We checked delayed jobs.

if the check is still happening.

Use past simple for the finished event:

We checked delayed jobs at 10:10.

The practical question is:

Is this a finished event, a current fact, or live work?

That question is more useful than asking only, "Is this about the past?"

There is one more useful test:

Can I point to the event on a timeline?

If yes, past simple is probably a good candidate:

09:30 -> We deployed the fix.
09:45 -> We found the config error.
09:50 -> We rolled back the deploy.
09:55 -> Error rate returned to normal.

If no, you may be describing a state, habit, ownership rule, or live activity:

The API owns the order state.
The worker runs every five minutes.
We are watching the queue.

Those sentences are useful, but they are not finished timeline events.

Negative Finished Events

Incident updates also need to say what did not happen. For negative past simple, use did not plus the base verb:

The worker did not restart.
The alert did not clear after rollback.
The migration did not change the user table.

This form is useful because it separates a failed expectation from a current state.

Compare:

The alert is still firing.
The alert did not clear after rollback.

The first sentence reports the current state. The second sentence reports a finished test: the team expected the rollback to clear the alert, but that event did not happen.

Both sentences may belong in the same update:

The alert did not clear after rollback. It is still firing, so we are checking the worker logs.

This gives the reader a clean chain:

• finished negative event: did not clear
• current state: is still firing
• live work: are checking

Use negative past simple when the missing event changes the next action. Do not use it just to list every thing that did not happen. Too many negative events can make the update harder to scan.

Common Confusions

Confusion: A finished event and a current result are the same thing

Why it is tempting:

Both can be connected to now.

Better model:

Past simple reports the finished event:

We rolled back the deploy at 09:50.

Present forms report the current result:

Checkout is healthy now.
The dashboard shows normal error rate.

Use both when both matter.

Confusion: Past simple sounds less important

Why it is tempting:

Live work can feel more urgent than finished work.

Better model:

Finished events are coordination signals. If the rollback is complete, the reader can test, monitor, or close a task. Past simple makes that decision easier.

Confusion: Every past sentence needs a long explanation

Why it is tempting:

Incident details are complex, so the sentence grows.

Better model:

Start with the finished event:

We restarted the worker.

Then add only the detail that changes the meaning:

We restarted the worker after the queue drained.

Trade-offs and Limits

Past simple improves timeline clarity. It makes finished actions easy to scan.

The trade-off is that past simple can hide the current effect if you stop too early.

This sentence reports an action:

We rolled back the deploy at 09:50.

It does not tell the reader whether the system is healthy now.

Add the current evidence when the result matters:

We rolled back the deploy at 09:50. Error rate is normal now.

Past simple also does not prove that the work succeeded. A team can finish an action and still have a problem:

We restarted the worker, but the queue is still growing.

You can see the boundary when a reader asks:

So what is true now?

If that question is still open, combine past simple with a present-state sentence.

Check Your Understanding

Check: Which sentence best reports a finished action?

A. We are rolling back the deploy. B. We rolled back the deploy at 09:50. C. The deploy owns the rollback.

Think first, then reveal.

Answer: B. rolled back reports a finished action, and at 09:50 places it on the timeline.

Check: The team is still checking delayed jobs. Which sentence is clearest?

A. We checked delayed jobs. B. We are checking delayed jobs. C. We check delayed jobs yesterday.

Think first, then reveal.

Answer: B. The work is live, so present continuous is clearer.

Practice

Revise this rough incident note:

checkout ok now / rollback 09:50 / errors normal / we watching queue / bad config found

Model answer:

Checkout is healthy now. We found a bad config value and rolled back the deploy at 09:50. Error rate is normal. We are watching the queue for delayed jobs.

Why it works:

• is healthy reports the current state.
• found and rolled back report finished events.
• is normal reports current evidence.
• are watching reports live work.

Now write a second version where the rollback did not fix the incident.

Model answer:

We rolled back the deploy at 09:50, but checkout is still slow. Error rate is still high, and we are checking delayed jobs.

Past simple says what the team completed. Present forms say what is still true.

Daily Practice Lines

Say or write these lines during the day:

We deployed the fix at 09:30.
The worker restarted after the deploy.
The alert cleared five minutes later.

Then keep one present-form review line from the previous lessons:

The dashboard shows normal error rate now.

Change one technical noun:

fix -> config -> migration -> cache -> worker

Keep asking: is this event finished, true now, or happening now?

Resources

• [ARTICLE] Cambridge Dictionary Grammar: Past simple
  • Link: https://dictionary.cambridge.org/grammar/british-grammar/past-simple-i-worked
  • Focus: Review the basic form for completed past actions.
• [ARTICLE] Cambridge Dictionary Grammar: Past continuous
  • Link: https://dictionary.cambridge.org/grammar/british-grammar/past-continuous-i-was-working
  • Focus: Compare finished actions with actions in progress in the past.
• [REFERENCE] Microsoft Writing Style Guide: Be clear and concise
  • Link: https://learn.microsoft.com/en-us/style-guide/welcome/
  • Focus: Keep incident and status sentences direct.

Key Takeaways

• Use past simple for finished events in a technical timeline.
• Add a time anchor when the order of events matters.
• Do not use past simple for current facts or live work.
• Combine past simple with present forms when the reader also needs the current result.