Some folks say data is the lifeblood of our business, but that metaphor falls short. After 20 years in this space, I can tell you data is more like the nuclear core that powers our business: potent yet dangerous, it can propel us to new heights or blow up in our faces. It's why I've come to love what most people hate: policy. Done right, policy acts as the reactor control system for our "nuclear engine," ensuring we harness its power safely and efficiently. However, creating effective policies isn't easy. Today, I want to highlight some techniques I've discovered along my journey—sometimes the hard way. I think of them as the advanced technology that optimizes and controls the nuclear engine of our data.

Blueprints: Style as a Vehicle for Meaning

Think of writing a policy like writing code. Well-structured code is easy to interpret, and the same goes for policy. Structure is the “X marks the spot” of good policy – not every map uses it, but when they do it saves everyone a lot of time and effort. Consistent style helps readers know what to expect and where to find information. For example, if each policy begins with a purpose followed by a background section, readers will know not to look for background information in the purpose section, reducing confusion (and complaints!). Like good code, sets of well-crafted policy follow a consistent, logical structure.

Consistency is Key: Avoiding Chaos

Consistency is boring, right? Well, in policy, it’s crucial for interpretability. When policies follow a consistent format and use the same terminology throughout, users can more easily understand and apply them. For example, imagine a policy on data security. If one section refers to "sensitive data" while another says "confidential information," readers might be confused about whether these terms mean the same thing. Using consistent terminology avoids this confusion. Establishing a style guide is like setting coding standards, helping maintain uniformity and clarity across documents.

The Necessary Evil of Definitions

I know, nobody likes reading definitions sections. They can feel like speed bumps in your flow. But trust me, they’re necessary. Without them, users will be lost, constantly wondering what certain terms mean. By putting a clearly-sourced terms section at the beginning, you’re giving everyone a legend to follow before they dig into the text. Think of it like defining constants and variables with meaningful comments at the start of your code: it makes everything easier to interpret, maintain, and debug.

The Perils of Adjectives: Clarity not Confusion

Look, we all learned in school how to plumb the thesaurus for those fancy 5-cent words to spice up our writing. It might have earned you extra points on a quiz, but in policy writing, it multiplies complexity, like bespoke bits of code. They introduce ambiguity and make things harder to understand. Words like "significant," "reasonable," or "appropriate" are subjective and open to interpretation, much like unclear variable names in code. Instead, use precise, quantifiable terms that leave little room for misinterpretation. "importantFrodoPotatoes" might be cute and make sense at the time, but it's no substitute for just saying what you mean.

Lists: Bugs not Features

Let's talk about lists. It’s tempting to think listing everything out in a policy makes it clearer, right? Wrong. Lists can be little hobgoblins that sneak in confusion and loopholes. While they might seem to provide clarity, they often create gaps and chances for teams to wriggle or fall out of compliance. For example, what's the value in listing apples, oranges, bananas, and raspberries when you could just say "fruits"? Not only does this simplify the policy, but it also stops the inevitable question about whether plums are included. Long lists also make readers' eyes glaze over. So, it's almost always preferable to consolidate the list into a broader category. This approach makes the policy clearer and reduces misunderstandings, much like using well-defined modular functions in code instead of overly specific, convoluted ones.

Leveraging Published Standards: Standing on the Shoulders of Giants

You know those moments when you realize someone else has already done all the hard work for you? That's what published standards are like. They’re your best friend in policy writing. They provide a common language that everyone in the field can understand. Using these standards saves you from reinventing the wheel and ensures that your policies are more easily understood by new hires, regulators, and auditors.

Defining Scope and Sticking to It: Good Handoffs Make Good Neighbors

Here's the deal: you’ve got to know your boundaries. Clearly defining the scope of your policy is critical. Think of it like coloring within the lines. If your policy is about network access controls, don’t start talking about budget approvals. That’s not your lane. Keeping the scope focused ensures clarity and prevents mission creep. You don’t want to dictate how another team designs or implements their particular module. By defining precise interfaces and responsibilities, each team can innovate and optimize their module while ensuring seamless integration and communication.

Goals Over Guidelines: Letting Operations Operate (Safely)

Let's be honest, nobody likes being micromanaged. Policies should define the outcomes you want, not prescribe the exact steps to get there. Instead, explain what success looks like and how you'll measure it, then let the teams on the ground figure out the best way to make it happen. For example, instead of specifying in a policy that seven FTEs are needed to handle incoming requests, outline the service levels or response times you expect. By focusing on the desired outcomes and performance metrics, you empower teams to leverage their expertise and creativity to find the most efficient and effective solutions.

Final Thoughts: On Drafting Advanced Policy Technology

If the code controlling our data-powered nuclear engine is a tangled mess of inconsistencies, ambiguous terms, and endless lists, it’s a disaster waiting to happen, right? Our policies need to be as well-crafted as high-quality code to harness all this power safely. Clear structure, consistent terms, and precise scopes are essential. Using published standards and focusing on outcomes allows us to harness the immense power of our data safely and efficiently. Good policy is like good code: clear, consistent, and capable of handling complexity.

So, join me in becoming an advocate for clear, concise policy on your team. When you see a confusing or inconsistent policy, speak up and offer to help revise it. Together, we can make policies a tool for super powering the business, not a barrier to getting things done.

May 30, 2024