Drills

Every job that touches email expects you to triage a full inbox with no hand-holding: know what's actually urgent, catch a phishing attempt before it becomes a real problem, and reply professionally without cc'ing people who don't need to be there. This is the baseline "day one, no supervision" office skill — worth practicing before any admin, coordinator, or entry-level office role, and before you say "yes, I'm comfortable with email" in an interview.

Front desk, office coordinator, and support roles rarely hand you a fixed to-do list — new requests land while you're still working through the last one. This drill practices exactly that: noticing what just arrived, judging when a reply genuinely needs to go to everyone versus just one person, and handling a real time-boxed request before the window closes. If a job posting mentions "fast-paced" or "juggling multiple priorities," this is what that actually feels like.

Outlook rarely throws an error when something quietly didn't work — a recall fails silently, a rule overlaps an old one, a scheduled send never leaves the Outbox. This drill drops the numbered sequence and puts six of those moments into one inbox at once, the way an actual morning at your desk would.

Outlook sends whatever is in the window. The autocomplete guesses the wrong Priya, the CC field shows 29 clients each other's addresses, a forward carries the private thread beneath it. This drill runs you through six things worth a second look before you hit send, before a real one reaches the wrong person.

Outlook does exactly what its defaults say. The meeting shows only your time zone, a recurring edit can rewrite twelve weeks at once, the From line is your own address, the sharing link is open to anyone, and a distribution list hides who is on it. This drill runs you through six defaults worth checking before they cost you a client, an interview, or a confidential timeline.

Once you hit send there is no take-back. Reply All reaches hundreds, an attachment named Final carries internal comments, a BCC'd colleague can Reply All to your client, personal data typed into the body sits readable in every mailbox it touches, and a display name proves nothing about who is asking. This drill runs you through six of the ways a send goes wrong, before a real one reaches the wrong people.

Outlook decides what you see before you see it. Focused Inbox and the junk filter guess wrong on real people, a full mailbox forces a choice about what to keep, and delegate access changes who the reader thinks wrote a message. A lookalike reply can hide inside a real thread, and a calendar can hold an invite you never accepted. This drill runs you through six of them, before one costs you a client, a contract, or a password.

A Slack mistake rarely looks like one in the moment — the message sends, the reaction registers, the channel looks the same as any other. This drill drops the numbered sequence and puts six of those moments into one workspace at once, the way an actual workday would.

Slack tells you a message sent, not who noticed it. A reply buried in a thread, an alert silenced by a snooze, a status that expired early, a private channel made public with its whole history. This drill runs you through six of the quiet ways a message posts and still never lands, before a real one costs someone a decision.

Slack shows a name in the box, not who is behind it. A mention notifies no one if they're not in the channel, a shared channel includes people from another company, a pin outlives the truth it points at, and a scheduled message sends whatever it says when it fires. This drill runs you through six ways the audience is different from what you assumed, before a real message reaches the wrong people.

Slack makes the easy move look harmless — send, convert, paste, create — and never tells you where it will end up. A message can wake someone through Do Not Disturb, converting a group DM shows its whole history to the next person, a huddle decision exists only for whoever was in it, and text pasted from a canvas never updates. This drill runs you through six ways a message, a history or a decision lands somewhere other than where you meant, before it happens for real.

Slack makes the quick move easy: paste a link, click Allow, add a bot, type a command. The cost sits in the detail, such as who sees a document title, what an app is allowed to read, which reply in a thread is the last word. Nothing throws an error, so the habit of reading the fine print is the only safeguard.

A lot of Teams settings are only labels. A 30-minute slot doesn't end the call, an Announcement banner doesn't notify anyone, a cleared mention is still an unanswered question. This drill runs you through six places where what the label says and what Teams does come apart, before a real one costs someone a meeting or a file.

A Teams mistake rarely announces itself — the screen share starts fine, the meeting chat looks normal, the recurring meeting saves without complaint. This drill drops the numbered sequence and puts six of those moments into one workspace at once, the way an actual workday would.

Teams starts a lot of things open, and the defaults are quiet: adding someone to a chat can share its entire history, the lobby can let anyone straight in, a recording lands in front of every invitee, and a standard channel is visible to the whole team. This drill runs you through six settings worth checking before you act, before a real one exposes something to the wrong people.

Teams rarely tells you what a choice will do. A presenter can't admit anyone from the lobby, a recording expires on a date nobody mentions, deleting a synced file deletes it for everyone, and an Offline status doesn't silence a phone. This drill runs you through six choices whose real effect is easy to overlook, before a real one costs someone a meeting, a file, or a night's sleep.

In Teams, what you can fix afterwards depends on what you set up before. Version history, an approval's recipient, breakout assignments, a transcript, an archive and an attendance report each work one way, and nothing warns you when you pick the wrong one. This drill makes you see the mechanism before it matters.

Zoom rarely stops you before a mistake — a matched name isn't verified identity, a setting from last call doesn't carry into this one, a recording isn't ready the instant the call ends. This drill runs you through six of the quiet ways "it worked last time" stops being true, before a real call goes sideways.

Zoom remembers, assumes and defaults. It remembers your last camera and microphone state, ends a meeting when the host leaves unless someone else is assigned, shows pop-ups from the app you are sharing, and can run out of storage without stopping you. This drill runs you through six things worth checking before you hit start, before a real call runs into one of them.

Zoom rarely warns you when a meeting is set up to reach too far. A Personal Meeting ID is one permanent room, a passcode in the link is no passcode, and an approval setting does nothing for people already approved. These tasks make you check who each setting reaches before the meeting starts.

Most employers now run some form of security-awareness training in the first week — a phishing text, a suspicious call, someone asking to borrow your badge or your login. This drill runs you through six of those situations on real phone, network, and activity-log chrome before a real one catches you off guard. Walking into a job with good instincts here is a genuine, quiet advantage: it's one less thing new-hire training has to teach you, and it signals you won't be the reason for the next incident report.

Payroll and HR systems move real money and carry real legal exposure — a rushed reclassification, an unverified banking change, or a quiet off-the-books adjustment can turn into a wage claim, a fraud loss, or a compliance finding weeks later. This drill runs you through six of those moments on a real employee-record panel that actually updates, before a real one catches you off guard.

Scammers and legitimate software both use urgent language — tone alone was never a reliable signal, and treating it as one goes wrong in both directions: trusting a fake because it sounds official, or dismissing something real because it sounds alarming. This drill runs you through six of those tasks before a real one costs you.

On a computer the surface and the substance can differ. A display name can be set to anything, a link's text can hide its destination, a search result can offer a fake support number, and a cleanup app nudges you to delete the biggest file. This drill runs you through six everyday moments where looking underneath is the whole skill, before a real one costs a payment, a password or the only copy of a file.

Closing the books never comes one clean task at a time — it comes as a whole company file someone hands you, and it's on you to look at all of it before you call it closed. This drill drops the numbered sequence and puts six real problems into one file at once, the way an actual month-end handoff would.

A bill marked paid before it actually is creates a real risk of paying twice; a vendor call about a balance isn't the same as that balance actually being the most urgent one. Accounts-payable mistakes are cheap to catch this week and can cost a real vendor relationship if they surface next quarter instead.

A report can be technically generated correctly and still say the wrong thing — a personal expense sitting in the wrong category, the wrong accounting basis, a plug instead of a real fix. None of these throw an error. This drill runs you through six of the quiet ways a set of books looks done right up until someone in the meeting asks a real question about the number.

A balance can sit in the books for months looking harmless — a deposit never applied, a liability never paid, stock booked as an expense. None of it throws an error; the reports just read the money from the wrong place. This drill runs you through six of the quiet ways it happens, and what each fix actually changes.

Customer-side mistakes rarely look like mistakes. A hidden balance, a shaved invoice or a tidy category makes a report look cleaner while the real problem stays. This drill trains the habit of recording what actually happened to the money, and fixing rules and records at the source.

Xero rarely stops you from making a mistake — a journal that balances, a suggested match, a default that quietly carries forward all look fine on the surface. This drill runs you through six of the quiet ways the books end up wrong anyway, before a real one costs someone a decision made on bad numbers.

Xero accepts whatever account, type or date it is given. A changed account type doesn't restate a report already sent, one reminder template covers everyone the same way, and an aging report trusts the due dates it was handed. This drill runs you through six ways the books look finished and say something else, before a real report goes out on a number that isn't right.

Xero accepts a credit note, a payment or a bill without checking that the last step happened. An unallocated credit leaves an invoice overdue, an unapplied overpayment keeps a paid customer on the chase list, and a deposit coded to expense overstates the month. This drill has you finish six of those jobs in Xero's own screens before a wrong balance reaches a customer or a tax return.

FreshBooks runs on things you set up once — estimates, recurring templates, billable expenses, logged time — and it has no way to know when the real-world situation around them has changed. This drill runs you through six of the quiet ways something set-and-forgotten goes out wrong, before a real one costs a client's trust or a real invoice.

FreshBooks records what you do and no more. Logged time isn't billed until someone pulls it in, a reminder is only an email, new default terms don't touch an invoice already sent, and a balanced sheet can hide errors that cancel out. This drill runs you through six steps the software leaves to you, before a real client goes unbilled, unchased or misled.

Software like QuickBooks or Xero will stop you from saving an entry that doesn't balance — but it can't stop you from balancing the wrong accounts, misclassifying a transaction, or leaving out a line that should be there. This drill runs you through six of those tasks, the ones no software catches for you.

In bookkeeping the amount can be right and the books still wrong. A payment recorded as a new sale counts the revenue twice, a bank statement's credit is a debit in your books, sales tax collected is a liability and not revenue, and an owner's groceries are a draw. This drill runs you through six moments where the number is fine and where it lands isn't, before a real set of books is built on one.

An entry that balances can still put money in the wrong month, which makes one month look great and the next look bad. This drill practises the timing calls bookkeepers make at every month-end: deferring what is not yet earned or used, accruing what is owed but not billed, and spreading costs over the months they cover. Getting the month and the kind of account right is what makes a profit figure trustworthy.

A spreadsheet doing exactly what it's told isn't the same as it doing what you meant — a lookup, a sort, or a dedupe can run clean and still quietly produce the wrong list. This drill runs you through six of the ways that happens, before a real one erases or mismatches something nobody notices until later.

A workbook can look completely finished and still have real structural problems underneath — a print area that never grew, a sheet that's "protected" but not the way you think, a table that isn't a Table. None of these throw an error. This drill runs you through six of the quiet ways that happens, before a real one gets missed on the way out the door.

Real spreadsheet work never comes one clean task at a time — it comes as a whole workbook someone hands you, and it's on you to look at all of it before you send it back out. This drill drops the numbered sequence and puts six real problems into one workbook at once, the way an actual handoff would.

A report can look completely finished and still be wrong underneath — a pivot that never saw the correction, dates that quietly swapped days and months, a lookup that fails on a name that looks identical, a file still linked to someone else's drive. None of these throw an error. This drill runs you through six of the quiet ways that happens, before a real one goes out with your name on it.

A sheet can look checked and still be wrong underneath: rules that shade the wrong rows, validation that never inspected the pasted values, a formula that is off by one at the exact threshold, a rate that slid down a column, a date that recalculates itself. None of these show an error, so the only defense is testing the edges and looking at what is actually in the cells.

A shared, live spreadsheet fails quietly — a broken link doesn't error, an overwritten edit doesn't warn you, a stale share doesn't expire on its own. This drill runs you through six of the quiet ways a collaborative sheet gets out of sync with reality, before a real one costs someone a decision made on bad or missing data.

A Sheets setting usually does half of what its name suggests. Domain restriction locks out legitimate outsiders, Viewer access still allows copying, a warning is only a click, and a notification rule covers one person. This drill runs you through six settings that look like control and aren't, before a real sheet leaks, drifts or goes unwatched.

Sheets rarely shows an error when a formula quietly reads the wrong cells. A total can ignore a filter, a pivot can miss today’s rows, and a lookup can guess instead of match, and the sheet still looks finished. This drill runs you through six of them, so you learn to check what a number is actually built from before someone acts on it.

A formula that runs without an error isn't the same as a formula that answers the actual question — a guessed range, a missing condition, or an unnecessary layer of nesting all execute just fine and still give the wrong answer. This drill runs you through six of those quiet gaps between "it runs" and "it's right."

In a spreadsheet one small slip can spoil a whole column without an error. A formula without its equals sign is only text, a plain reference shifts when filled down, a click can land one row off, and a rate typed as 8 is a hundred times too large. This drill runs you through six small slips and their big misses, before a real sheet goes out with one of them in it.

A formula can run without an error and still be wrong. Filling, copying and recalculating change what a formula points at or when it runs. This drill trains you to check what a formula really did, not just that a number appeared.

A document rarely announces that it's not ready — the tracked changes look resolved, the merge looks complete, the search-and-replace looks done. This drill runs you through six of the quiet ways a document goes out not quite right, before a client, not you, is the one who finds it.

A document can look completely finished and still have a structural setting quietly working against it — a section that never inherited the right numbering, a watermark nobody remembered to clear, a style edit that rippled further than intended. This drill runs you through six of the quiet ways that happens, before a real one goes out the door.

What you see in Word is the page, not the file. Hidden text and properties travel with a template, a PDF prints whatever markup is showing, merging two copies by eye drops edits, and a blank alt-text field reads out as a file name. This drill runs you through six gaps between the screen and what the reader actually gets, before a real one reaches a client.

The words on the page are only half of a Word file. Blank lines holding a heading in place, a hand-typed bibliography, a banner that only looks like a lock, and text that spell check was told to skip all hold up until something changes. This drill runs you through six settings that sit behind the text, before a real document goes out with one of them wrong.

A long Word document holds together only through its structure, and nothing errors when that structure is missing. A caption typed by hand, a contents page nobody updated or a style fixed in the wrong file all look finished until the document changes or someone else opens it. This drill makes you look at the setting that decides it.

A shared, live document fails quietly — a checkmark can be wrong, a mention can silently not notify anyone, an old sharing link can still be live. This drill runs you through six of the quiet ways a document isn't actually as done, or as private, as it looks, before a real one reaches the wrong person or the wrong audience.

Docs doesn't do the follow-through for you. A table of contents only updates when refreshed, Accept All is live the moment you click it, a name typed without the @ isn't a mention, and turning off the notification doesn't turn off the access. This drill runs you through six steps Docs leaves to you, before a real document goes out with one of them missed.

What you see in the editor is not always what the reader gets. Pageless view hides headers and footers, linked charts keep old numbers until you click Update, and a Word file only names its fonts. This drill runs you through six ways a document goes out different from how it looked, before a real one reaches a client.

DocuSign rarely stops you from making a mistake — voiding, resending, and routing choices all go through without a warning, even when they throw away work already done. This drill runs you through six of those moments before a real one costs someone a signature they already had.

DocuSign confirms an envelope was sent, not that it can be signed. A CC sees only the finished copy, a required field can block completion, editing a template doesn't fix envelopes already sent, and a code goes to whatever number is on file. This drill runs you through six reasons an envelope sits unsigned, before a real contract stalls for a week.

DocuSign shows Sent and Completed whether or not the envelope is set up right. An access code in the same email, an optional Initial box, or a contract nobody downloaded all pass without an error. This drill trains you to check the setup, not just the status.

A file can look saved and still be lost, doubled or out of reach. Where it lives, how many copies exist, what its name really ends with and whether a drive finished writing decide if it is there when someone needs it. This drill runs you through six of those moments before a real one costs a quote, a schedule or a presentation.

Design roles are judged on finished work, not just software fluency — this drill mirrors that: a real brief, a handful of concrete decisions, and an actual flyer to show for it at the end, the same way a portfolio piece would.

Design roles are judged on finished work, not just software fluency — this drill mirrors that: a real brief, a handful of concrete decisions, and an actual social post to show for it at the end, the same way a portfolio piece would.

Design work gets sent back for reasons that have nothing to do with taste: text that fails a contrast check, too many fonts, small print nobody can read, a logo cut off at the trim. This drill hands you a flyer with those problems and measures the fixes live — a real contrast ratio, a real font count, a real safe-zone check — so you learn to see them before a printer or a client does.

Most Canva work is not one design, it is one message in several sizes. Resizing is where brands quietly break: off-palette colors sneak in, a headline hides under the Story profile bar, the logo shrinks below legibility, and one version keeps the old date. This drill practices catching all of those before anything is posted.

Most Canva work ends at a printer or a screen, and the problems are quiet: every size the same, text scattered across three edges, a photo that swallows the page, a web image sent to a print shop. This drill practices catching each one, with the consequence shown right on the page, before anything is printed.

Design roles are judged on finished work, and a screen that looks right in one state is only half done. This drill mirrors the handoff a developer actually needs: a clear hierarchy, the states nobody remembers to draw, and a layers panel that says what each thing is.

A Figma file can look finished and still be wrong underneath, because detached, hard-coded, and overridden layers all look right on the canvas. This drill has you check what each layer is actually linked to, and shows you what each shortcut costs the next person to open the file.

A Figma file can look done and still stop a developer cold: a status that promises too much, a logo that exports blurry, a layout that only works at the size you drew. This drill practices opening the panels a developer will open, and fixing what is wrong, before they do.

A product photo is judged on the finished image, not on which software you know — this drill mirrors that: a real shot, a handful of concrete retouching decisions, and an actual finished photo to show for it, the same way a portfolio piece would.

The gap between a photo that looks fine and one that is ready to publish is mostly invisible: a fill that covers the subject, an exposure change baked into the pixels, a file ten times too heavy. This drill mirrors the real prep job, decision by decision, and shows you the consequence of each on the image itself.

A picture that looks right on screen can still be a dead end for the next revision or the next screen it lands on. Erasing, baking in a filter, or flattening all look identical to the lasting version until the client asks for a change. This drill runs you through six of those moments, so the quick edit and the lasting edit stop looking the same to you.

Shopify rarely stops you from picking the wrong action — canceling a shipped order, leaving a product unpublished, skipping a shipping zone all go through cleanly, with the real problem showing up later as a refund dispute, a lost sale, or an angry customer. This drill runs you through six of those moments before a real one costs an order.

Shopify lets things go live and keeps them running. Fulfillment can be confirmed with tracking blank, a pricing rule matches a tag exactly, a fraud score is a signal and not a verdict, and a discount runs until someone ends it. This drill runs you through six things that stay live on a store after you set them, before a real one costs an order, a margin or a customer.

Shopify saves almost any change without a warning, so a refund, a price, a collection or a shipping rate can look finished and still be wrong. A refund doesn't restock unless you ask, a lower price isn't a sale without a compare-at price, and a collection or rate quietly drops anything that misses a condition. This drill runs you through six of them before a real one costs a sale, a margin or a customer.

An entry that looks right can still be wrong — a transposed digit, a duplicate contact, a placeholder standing in for real data. This drill runs you through six of the quiet ways a near-perfect record fails later, before a real one causes a failed mail-out or a wrong payment.

Data entry rewards exactness where it counts. A name without its accent can't be found, a retyped ID can swap two digits, a date like 12/03 means two different days, and one wrong first record copies into every row below it. This drill runs you through six moments where being exact — or checking at the right point — is the whole job, before a real one spreads.

A form can change what you typed and never say so. Names get reshaped, zeros vanish, short years change century, and autofill brings back yesterday's address. This drill trains you to read the saved record against the source, not against what you remember typing.

Tableau rarely stops you from making a mistake — a stale refresh, a technically valid chart, a workbook-level permission all look fine on the surface. This drill runs you through six of the quiet ways a dashboard goes wrong anyway, before a real one costs someone a decision made on bad or misleading data.

A Tableau dashboard can be built and still not work for the person using it. A filter action needs the right trigger, a filter reaches only the sheets it's applied to, a parameter does nothing until a calculated field uses it, and one period's ranking isn't a trend. This drill runs you through six ways a dashboard looks finished and fails the viewer, before a real one goes out.

Tableau views rarely show an error when they compute the wrong answer. A rate, a join or a filter order can quietly change a total that people then repeat in meetings. This drill trains you to check a view against a number you trust before you publish it.

NetSuite will let a number look fine in isolation even when it isn't — an order that clears on its own can still be short once every other order drawing from the same stock is counted, and a flag doesn't stop a payment by itself. This drill runs you through six of the quiet ways that gap shows up, before a real one costs an order or a payment.

NetSuite records your half and leaves the loop open. A sent PO isn't binding, an RMA isn't a credit until the vendor approves it, a reorder point is only as good as the number entered, and a valuation shows only what has been posted. This drill runs you through six ways a purchasing or inventory record looks settled and isn't, before a real customer promise or month-end rests on it.

In NetSuite a record can be saved, approved and closed while the posting is wrong. A bill dated today lands in today's period, an Item Fulfillment that never shipped cannot be invoiced, and a blank Department drops spend off the report. This drill makes you check status, period and posting instead of trusting that the record exists.

ShipStation lets you undo plenty of things — but not everything, and not always the way you'd expect. A scanned label, a completed batch, and a permanent automation rule all behave differently once they're in motion. This drill runs you through six of those moments before a real one costs an order.

ShipStation shows the label, the rate and the count. It doesn't show that a preset weight is only the empty box, that two accounts share a nickname, that a transit estimate isn't a promise, or that the cheapest postage isn't the cheapest parcel. This drill runs you through six things that aren't on the label, before a real shipment pays for them.

A label printing is not proof the shipment is set up right. Missed store updates, rule order, address flags, coverage, ship-from and customs data all fail quietly and cost money or customers later. This drill practises checking the setup behind the label.

Salesforce will let you create a record that already exists, close a deal with no paperwork attached, and apply a discount nobody approved — none of it throws an error. This drill runs you through six of the quiet ways the system stays clean or gets messy, before a real duplicate account becomes someone else's problem to untangle.

A CRM stays accurate only while someone keeps it that way. A lead sits under an integration user, a deal keeps its Commit status while the buyer goes quiet, old close dates inflate the pipeline. This drill runs you through six of the ways a Salesforce record goes stale without any warning, before a real one costs a deal or a forecast.

Salesforce will merge the wrong values, accept a made-up tax ID, and save a report whose filters quietly hide deals, and none of it shows an error. This drill runs you through six of those quiet ways a record looks fine and is wrong, before a real merge, report, or flow causes damage.

HubSpot rarely stops you before a mistake compounds — a stale list quietly includes the wrong person, a form collects submissions nobody's watching, a workflow trigger error fires again and again instead of failing once. This drill runs you through six of the quiet ways that happens, before a real campaign or automation goes out wrong at scale.

HubSpot records what you enter and stops there. An unlogged call leaves nothing behind, a flag notifies no one, an assignment doesn't ring anyone's phone, and a sent email can't be recalled. This drill runs you through six moments where the record is right and the person who needed to know never found out, before a real one costs a deal or a customer.

HubSpot runs workflows, lists and sequences on its own and rarely flags a mistake. A re-enrolled contact gets the same email again, a static list keeps people who no longer qualify, and a backwards lifecycle change is skipped with no error. A merge keeps the primary record's values, and a mapped form field can overwrite a correct one. This drill runs you through six of those quiet failures before a real send or merge makes one of them permanent.

Asana rarely stops you before a mistake — a custom field doesn't carry to a new project automatically, a subtask doesn't inherit its parent's owner or deadline, a dependency is a visual flag, not a lock. This drill runs you through six of the quiet ways something looks handled without actually being handled, before a real deadline or handoff slips through.

Asana holds the work but doesn't chase it. A task with no due date drops off deadline views, an @mention lands in an inbox nobody is watching, a portfolio doesn't grant access to its projects, and completing a parent leaves its subtasks open. This drill runs you through six ways work slips through a project that looks fully organized, before a real one misses a deadline.

Asana does what you set, not what you meant. A project’s dependency setting decides whether moving one date moves the tasks behind it, and a template dates every task from whatever day you pick. A rule runs on every task that matches its trigger, and a Done column completes nothing on its own. This drill runs you through six of these quiet failures, plus a filter that hides overdue work and a repeat that drifts, before a real plan slips.

Zendesk rarely double-checks that an action actually fits before it fires — a macro applies its status change whether or not it matches the ticket, a merge can't be un-done, a VIP tag never reaches back to reprioritize what's already in the queue. This drill runs you through six of the quiet ways that happens, before a real customer gets the wrong response.

Zendesk stores the label and stops there. A view matches a ticket without telling anyone, an Urgent priority doesn't reorder a queue, and a reply box left on Public sends whatever you typed to the customer. This drill runs you through six ways a ticket ends up correctly labeled and in front of nobody, before a real one waits overnight.

Zendesk lets a ticket be marked Solved while the customer is still waiting, and it does not warn you when a rule repeats itself or a reply reaches the wrong person. A view that requires an assignee never shows the tickets nobody picked up, and two triggers can quietly undo each other. This drill runs you through six ways a ticket looks closed out and still isn't, before a real customer is left waiting.

Mailchimp rarely stops you before a mistake ships — a segment can match zero people with no warning, a campaign can send with a placeholder subject line, an A/B test can declare a "winner" from a setup that never answered the real question. This drill runs you through six of the quiet ways that happens, before a real campaign goes out wrong to a real audience.

Mailchimp sends what you schedule and reports what it counts. Inactivity is judged by opens alone, a custom footer can leave without an unsubscribe link, the schedule follows the account's time zone, and open rates can be inflated by mail privacy. This drill runs you through six ways an email goes out fine and reaches the wrong people, at the wrong time, or nobody real at all.

Mailchimp does what the settings say and rarely warns you. An import status applies to every row, a segment built on the wrong field still shows a healthy count, and a journey that accepts imports welcomes customers you already have. This drill runs you through six ways a campaign sends fine and still reaches the wrong people, before a real one does.

Greenhouse rarely stops a mistake before it happens — a stage skip goes through, a mismatched interview panel gets scheduled, an offer with no real approver gets created, all with no warning. This drill runs you through six of the quiet ways that happens, before a real candidate or a real hire gets the wrong outcome.

Greenhouse counts whatever it is given. A scorecard can be submitted half filled, a scoring rubric can change mid-search, a source can be wrong without showing it, and a split vote averages to a plain Yes. This drill runs you through six ways hiring data looks clean and means something else, before a real decision rests on it.

A Greenhouse record can look finished while the candidate was never told, the interview has nothing to score, or the hire sits on the wrong job. Nothing warns you, so the damage shows up later in candidate experience and in reports. These tasks train you to open the record and check what the candidate and the reports actually see.

When I Work tracks the schedule as planned, not always what's actually true — a rate stays the position default until someone sets an override, a weekly-hours check misses a state's daily overtime rule, a labor cost number reflects scheduled hours, not the real clocked ones. This drill runs you through six of the quiet ways that happens, before a real paycheck or a real understaffed shift catches someone off guard.

When I Work shows the schedule as it was entered, not as the day will go. A new location has no clock-in radius until someone sets one, coverage checked on Tuesday can be short by Friday, a headcount rule doesn't know about the festival, and a forgotten clock-out becomes paid hours. This drill runs you through six ways a schedule looks fully covered and isn't, before a real one runs short.

A When I Work schedule can look complete while the team never got it. Approved time off, hours across locations, and settings that stack leave no error behind. Checking who was actually notified and what the totals really are is what keeps people from showing up wrong or being paid wrong.

Square rarely stops a mistake before it happens — a duplicate price goes live, a missed tax category quietly undercharges every sale, a void window closes with no warning that it's gone. This drill runs you through six of the quiet ways that happens, before a real customer gets charged wrong or a real dispute gets lost for lack of evidence.

Square records what is rung up and nothing else. A manual discount only applies when a cashier remembers it, a refund doesn't restock the shelf, a dispute is decided on the evidence you submit, and cash outside the register never reaches the report. This drill runs you through six ways a sale looks finished at the counter and isn't, before a real one costs the business money.

A Square sale can go through with no error and still carry the wrong tax, the wrong discount or the wrong permissions. Nothing warns you when a store has no tax set or two discounts stack. This drill makes you check the settings behind the sale, as you would on the job.

ADP runs on dates and windows. A future-dated change sits queued until its date, a qualifying-life-event window closes without a warning, an accrual cap fills without notice, and a garnishment keeps deducting until someone ends it. This drill runs you through six moments where the clock is the whole problem, before a real employee is the one who pays for it.

A payroll register can total correctly and still pay one person wrong. Corrections made after the cutoff wait for the next payroll, a bonus keyed as regular pay is taxed and deferred wrong, and a garnishment with no limit can take more than the law allows. This drill makes you open what sits behind the totals before the checks go out.

Workday rarely keeps everything in sync on its own — a reorganization moves the person you selected and nobody else, a compensation grade only applies going forward, a budget report reflects last week's numbers, not this morning's spending. This drill runs you through six of the quiet ways something gets left behind, before a real org chart, paycheck, or budget goes visibly wrong.

Workday accepts the code, calculates the raise, and displays the criteria — and leaves the rest to a person. A valid budget code isn't Finance's sign-off, an escalation doesn't raise a ceiling, and a filed leave doesn't tell Payroll. This drill runs you through six steps Workday shows and doesn't finish, before a real hire, raise, or leave is approved on paper and never actually done.

Workday records exactly the date and the kind of change you enter. A date a week off, or a Correct where a Rescind was needed, flows straight into pay, history and access. These six tasks make you check the date, the transaction type and the record you changed.

Gusto will run payroll on whatever it's given — a pay date that shifts, a deduction over a state cap, a mistyped routing number, a misclassified worker. This drill runs you through six of the quiet ways that happens, before a real one costs someone a paycheck.

Gusto pays exactly what it is given. A work location can default to a home address, a flag marks an entry without correcting it, overtime can be daily as well as weekly, and last year's tax rate stays until someone changes it. This drill runs you through six ways payroll processes exactly what was entered and gets it wrong, before a real paycheck goes out.

Gusto accepts these setups without a warning. The mistake shows up later as a short paycheck, a late deposit, or a notice about an unpaid state tax. This drill trains you to check the paycheck and the filing, not the green tick.

BambooHR saves the record and stops there — a new department stays empty, a posting stays internal, a new hire gets no access, a raise only starts from its entry date. This drill runs you through six of the quiet ways a record saves without the job actually being done.

BambooHR records what is entered and stops there. A wrong benefits tier is locked until open enrollment, an accrual change doesn't recalculate old balances, a denial offers no next step, and ending active status doesn't end system access. This drill runs you through six ways a people record looks complete and leaves the real work undone, before a real employee pays for it.

A saved BambooHR record can look finished and still be wrong underneath. Nothing shows an error, so the wrong balance, date or access sits there until someone is paid wrong or sees data they shouldn't. This drill trains you to reopen the record and check what it says now.