Apologies, bad news and escalations

Three emails told one client that a release would slip. The one written in four parts had everything a reader needs, and the other two had one part between them, along with three apologies, a guess at the cause and the word “soon” for the next update.

Bad news goes out early, with four parts: what happened, who is affected and how, what you are doing, and when the next update comes. An apology works when there is only one, and it names what went wrong. Escalationsescalation: Asking someone with more authority to decide or to unblock work, after your own request and your reminders have not worked. ask the person who can decide, with what you tried. Incident updates repeat the four parts on a schedule that you keep.

Bad news goes out early, in four parts

On Thursday at 12:00 Eastern Time, Kavya’s final tests found that Friday’s release would not fix the CSV export for every account. She could write to Daniel, the client, at once, or hope for a fix by Friday and tell him then. A day of notice is worth more to him than a day of hope, so she wrote at once, in four parts, with every time in his zone:

Each part answers a question the reader would otherwise send back: what changed, does it affect me, what are you doing, and when will I hear more. The order matters too. The news comes first, as Microsoft’s style guide asks for anything a reader scans: “Lead with what’s most important.” Say only what you know: a guess about the cause, such as “probably the database team”, has to be taken back in the next update if it is wrong.

The program checks Kavya’s email and two others that told Daniel the same news: one sent late, one in a panic.

// Three emails that tell a client the same bad news, checked for the four parts of a bad-news message (what happened,
// who is affected and how, what we are doing, and when the next update comes, with a time and a zone) and for three
// slips: stacked or boilerplate apologies, guessing at a cause, and times nobody can plan around.

const PARTS = [
  ['what happened', /\b(?:is|has been) (?:delayed|moving|moved)\b|\b(?:moves|failed|missed|found|is down|will not)\b/i],
  ['who is affected, and how', /\b\d+ of (?:your )?\d+\b|\baffect\w*\b|\bcan keep using\b|\bcannot use\b/i],
  ['what we are doing', /\b(?:we are|we're) (?:fixing|testing|replacing|rolling|checking)\b|\bwe will (?:fix|test|release)\b/i],
  ['the next update, with a time and zone', /\bnext update\b[^.?!]*\b\d{1,2}:\d{2}\b[^.?!]*\b(?:UTC|IST|ET|Eastern Time)\b/i],
];
const APOLOGY = /\b(?:sorry|apologi[sz]e|apologies)\b/gi;
const BOILERPLATE = /\bsorry for (?:the|any) inconvenience(?: caused)?\b/i;
const GUESS = /\b(?:probably|maybe|might have been|we think it was|seems to be)\b/i;
const VAGUE = /\b(?:soon|shortly|some issues|unforeseen|might get delayed)\b/gi;

function check(text) {
  const missing = PARTS.filter(([, re]) => !re.test(text)).map(([name]) => name);
  const flags = [];
  const apologies = (text.match(APOLOGY) ?? []).length;
  if (apologies > 1) flags.push(`${apologies} apologies: say sorry once, for something specific`);
  if (BOILERPLATE.test(text)) flags.push(`"${text.match(BOILERPLATE)[0]}" is boilerplate: name what you are sorry for`);
  if (GUESS.test(text)) flags.push(`"${text.match(GUESS)[0]}": a guess at the cause; say what you know`);
  for (const m of text.matchAll(VAGUE)) flags.push(`"${m[0]}" tells the reader nothing they can plan with`);
  return { missing, flags };
}

const EMAILS = [
  ['The late, vague email (Friday 15:00 Eastern Time)', `Hi Daniel,
We are facing some issues with the release and it might get delayed. Will update soon.
Regards,
Kavya`],
  ['The panicked email (Thursday 18:00 Eastern Time)', `Hi Daniel,
Extremely sorry for the inconvenience caused!! We deeply apologise. Due to unforeseen technical challenges, which were probably caused by the database team, the release is delayed. Sorry again, we are trying our best.
Regards,
Kavya`],
  ['The four-part email (Thursday 12:00 Eastern Time)', `Hi Daniel,
Friday's release of the CSV export fix is moving to Tuesday. Our final tests found that exports for 2 of your 30 merchant accounts still show the next day's date after 20:00. Your finance team can keep using the current export, which is correct for the other 28 accounts. We are fixing the date rule for those two accounts today and will test it on Monday. I'm sorry for the delay. I will send the next update by Monday 17:00 Eastern Time.
Thanks,
Kavya`],
];

for (const [name, text] of EMAILS) {
  const { missing, flags } = check(text);
  console.log(`${name}: ${PARTS.length - missing.length} of ${PARTS.length} parts`);
  for (const m of missing) console.log(`  missing: ${m}`);
  for (const f of flags) console.log(`  flag: ${f}`);
}

The late, vague email (Friday 15:00 Eastern Time): 0 of 4 parts
  missing: what happened
  missing: who is affected, and how
  missing: what we are doing
  missing: the next update, with a time and zone
  flag: "some issues" tells the reader nothing they can plan with
  flag: "might get delayed" tells the reader nothing they can plan with
  flag: "soon" tells the reader nothing they can plan with
The panicked email (Thursday 18:00 Eastern Time): 1 of 4 parts
  missing: who is affected, and how
  missing: what we are doing
  missing: the next update, with a time and zone
  flag: 3 apologies: say sorry once, for something specific
  flag: "sorry for the inconvenience caused" is boilerplate: name what you are sorry for
  flag: "probably": a guess at the cause; say what you know
  flag: "unforeseen" tells the reader nothing they can plan with
The four-part email (Thursday 12:00 Eastern Time): 4 of 4 parts

The four-part email has every part and no flags. The late one has none of the parts, and “soon” and “some issues” tell Daniel nothing he can plan with. The panicked one says only what happened, and buries it under three apologies, a boilerplate phrase and a guess that blames another team.

One apology, specific, then the fix

“Extremely sorry for the inconvenience caused!! We deeply apologise.” Neither sentence says what the writer is sorry for, and three apologies in one email make the reader wonder how bad things really are. An apology works when there is only one, it names what went wrong, and it comes after the facts, followed by the fix:

Say I’m sorry when the miss is yours and we’re sorry when it is the team’s. Then move on to the new date and the plan, because the fix is what the reader will act on. Stacked apologies push that plan down the page.

The rest of this lesson uses the same parts for harder messages. Blameless wording describes what the system did, not who made it fail. Escalations ask someone with more authority to decide. And incident updates repeat the four parts on a schedule, saying in each when the next one comes.

Blameless wording: systems and decisions, not people, line by line Pro: opens with a Pro, Premium or Ultimate pass

Escalating a blocker: the email before and after, and who is copied Pro: opens with a Pro, Premium or Ultimate pass

Incident updates on a schedule: an outage minute by minute, timed Pro: opens with a Pro, Premium or Ultimate pass

Practise: a bad-news email in four parts

The exercise holds an email that tells a client’s QA lead about a late build, written in a panic. Rewrite it until the sample tests pass:

// Rewrite Kavya's email to Lena in four parts. Keep the greeting as the first line and the closing line and the name
// as the last two, separated by \n.
export const email =
  'Hi Lena,\n' +
  'Extremely sorry for the inconvenience caused!! Due to some unforeseen issues, which are probably in the payment ' +
  'SDK, the build might get delayed. We deeply apologise and will update you soon.\n' +
  'Regards,\n' +
  'Kavya';

import { test, assert } from 'mysmartcopilot:test';
import { email } from './email.mjs';

// The lesson's four parts of bad news, and its apology rules.
const lines = email.split('\n');
const body = lines.slice(1, -2).join(' ');
const sentences = body.split(/(?<=[.!?])\s+/).filter(Boolean);
const APOLOGY = /\b(?:sorry|apologi[sz]e|apologies)\b/gi;
const CLOSING = /^(?:Thanks|Thank you|Many thanks|Regards|Best regards|Kind regards|Best),$/;

test('the first sentence says what happened: the build and its new day', () => {
  const first = sentences[0] ?? '';
  assert.ok(/\bbuild\b/i.test(first) && /\bFriday\b/.test(first), `start with the news, the build and Friday: "${first}"`);
});

test('it says who is affected, and how', () => {
  assert.ok(/\bAndroid 14\b/.test(body), 'say which phones are affected: Android 14');
  assert.ok(/\b(?:build 2\.3|can keep)\b/i.test(body), 'say what the testers can keep using: build 2.3');
});

test('it says what the team is doing', () => {
  assert.ok(/\b(?:we are|we're) (?:fixing|testing)\b|\bwe will (?:fix|test)\b/i.test(body), 'say what you are doing: We are fixing …');
});

test('it gives the next update a time and a zone', () => {
  assert.ok(/\bnext update\b[^.?!]*\b\d{1,2}:\d{2}\b[^.?!]*\b(?:UTC|CET|CEST|IST)\b/i.test(body), 'say when the next update comes, with a time and its zone');
});

test('it apologises once, for something specific', () => {
  const n = (body.match(APOLOGY) ?? []).length;
  assert.equal(n, 1, `${n} apologies: say sorry once`);
  assert.ok(!/\binconvenience\b/i.test(body), '"inconvenience caused" is boilerplate: say what you are sorry for');
});

test('no guesses, no vague words, short sentences and a closing line', () => {
  assert.ok(!/\b(?:probably|maybe|might)\b/i.test(body), 'say what you know, not what the cause might be');
  assert.ok(!/\b(?:soon|some issues|unforeseen)\b/i.test(body), 'give facts and times, not "soon" or "some issues"');
  assert.ok(!/!!/.test(email), 'no "!!"');
  for (const s of sentences) {
    const n = s.split(/\s+/).length;
    assert.ok(n <= 25, `${n} words: "${s}"`);
  }
  assert.ok(CLOSING.test(lines.at(-2) ?? ''), 'end with a closing line, such as "Thanks,", before the name');
});

Then try the questions on bad news and apologies:

Interview questions

Warm-up (fresher to mid-level): What makes an apology in a work email specific?

It names what went wrong and how it affects the reader, once: “I’m sorry I missed the 17:00 IST deadline for the test report”, not “sorry for the inconvenience caused”. It comes after the facts, and the fix follows it at once: the new time, and what you are doing so that it does not happen again. One apology is enough.

Three longer questions of this module’s bank build on this lesson:

Key takeaways

• Send bad news the day you know it, with what happened, who is affected and how, what you are doing, and the next update with a time and a zone.
• Apologise once, for something specific, after the facts, and move straight to the fix and the new date.
• Say only what you know: a guess about the cause, or a word such as “soon”, gives the reader nothing to plan with.