Key takeaways
- Separate a genuine exception from a preference dispute before opening the process.
- Require a written case with the rule, the reason, the scope, and the expiry condition.
- Name who can approve an exception and what they are accountable for.
- Record the exception beside the code so the next reviewer sees it in context.
- Review exceptions quarterly for patterns that suggest the rule itself should change.
Why exceptions need a process
Every coding standard meets a case it did not anticipate. A team can ignore the rule quietly, follow it and accept a worse outcome, or approve a documented exception. The first option erodes the standard because nobody knows which rules are still real. The second can produce unnecessary work. A small exception process keeps the standard credible without making it rigid.
The process also protects the offshore developer. A developer who follows the rule and produces an awkward result may be blamed for a decision they did not make. A documented exception shows that the deviation was considered and approved. That record is useful during review and during a later handover. It turns a judgment call into something the team can inspect.
Define what counts as an exception
An exception is a deliberate deviation from a written rule for a stated reason. A preference dispute is not an exception. If the rule is unclear, fix the rule rather than approving a deviation. If the rule is clear and the team disagrees with it, that is a standards discussion. Separating the two prevents the exception log from becoming a list of unresolved opinions.
Name the rules that can be excepted and the ones that cannot. Security, privacy, and accessibility baselines usually belong in the second group. Style and structure rules are more likely to have legitimate exceptions. The list should be short and visible. A developer should know within a minute whether their case is eligible.
Require a written case
Ask for four facts: the rule, the reason for the deviation, the scope of the exception, and the condition that ends it. The reason should describe the concrete problem, not a general preference. The scope should name the files, modules, or package affected. The expiry condition might be a date, a version, or the completion of a migration.
Keep the written case short enough to read in review. A paragraph and a link to the relevant code are usually enough. If the case needs a long argument, the rule may need a broader review. The record should let a new reviewer understand why the code looks different without asking the original author. That is the test of a useful exception.
Set the approval boundary
Name the role that can approve an exception and the role that must be informed. A tech lead can usually approve a local style exception. A security or privacy exception needs the owner of that control. Do not let the same person approve an exception and waive the review that would catch its risk. The boundary should be written where the team plans work.
Give the approver a clear question to answer. They are deciding whether the deviation is acceptable for this scope and duration, not whether the rule is good. That framing keeps the decision small. If the approver thinks the rule is wrong, they should open a standards change separately. Mixing the two decisions slows both.
Record the exception beside the code
Put a short comment or annotation next to the code that deviates. Include the rule identifier, the approval reference, and the expiry condition. A separate spreadsheet is easy to forget and hard to find during review. The code-level note keeps the context where it is needed. It also makes the exception visible to a future maintainer who never saw the approval.
Link the code note to the full written case. The note should be short, and the case can carry the detail. If the tooling supports a lint suppression, use the same identifier so a search finds every instance. Avoid anonymous suppressions that hide the reason. An exception that cannot be found is indistinguishable from an accident.
Review exceptions for patterns
Review the open exceptions each quarter. Group them by rule and look for a rule that generates repeated deviations. A rule with many exceptions may be wrong for the codebase or poorly explained. That is a signal to revise the standard, not to keep granting approvals. The review should produce a decision about the rule, not only a status update.
Close exceptions that have passed their expiry condition. An expired exception is a hidden deviation that nobody is watching. Ask the owner to either renew it with a new reason or remove the deviation. Keep the closed record for history. A small log that is actively pruned is more useful than a large one that is never read.
Communicating the exception
Tell the reviewers who will see the code that an exception exists. A short note in the pull request description is often enough, with a link to the written case. Reviewers should not have to discover the deviation by comparing the code to a standard they may not remember. The note also gives them a chance to challenge the reason before the change merges. Transparency is what keeps an exception from becoming a quiet habit.
Do not use the exception as a way to avoid a conversation about the rule. If the same reviewer challenges the same exception every month, the rule or the explanation needs work. Update the written case with the answer rather than repeating it in chat. Over time, the exception notes become a useful record of where the standard meets real code. That record is more valuable than a perfectly uniform codebase.
Limitations
A process cannot make every rule sensible. Some standards are inherited from a client, a regulator, or an older platform and cannot be changed by the pod. In those cases the exception process can only document the cost and route it to the right owner. It should not pretend that a local approval settles an external requirement.
The process also adds a small amount of friction, and a team under pressure may skip it. If exceptions are routinely undocumented, the problem is usually the approval path rather than the developers. Shorten the path before adding more reminders. A process that is easy to use is more likely to be followed during a busy release.
Questions about assessing Philippine developers
What is the difference between an exception and a rule change?
An exception applies to a specific scope and expires. A rule change applies to everyone and replaces the standard. Keep the two decisions separate.
Who should approve an exception?
The owner of the rule or control, not the author of the code. Security and privacy exceptions need the relevant control owner.
How long should an exception last?
Until a named condition is met, such as a migration date or a version upgrade. Review it at that point instead of letting it renew silently.
