The Honest Way to Make Decisions When You Don't Have All the Data
I spent about four years working compliance and risk management at a mid-size fintech firm before burning out and moving to a smaller company where the stakes were lower. During that time, I saw a lot of people struggle with decisions that weren't covered by any policy document. The rulebooks only go so far. They always do. What happens when the situation falls into a gray area that nobody anticipated is where most teams fall apart, and most of that comes down to one habit: stopping long enough to actually think about what you're comfortable with. This isn't a software download or a framework with steps. It's a decision filter. You run a choice through it the same way you'd run it through a checklist, but the checklist lives inside your head instead of on paper. The method goes something like this: you identify the decision you need to make, you lay out your options plainly, and then you ask yourself what would happen if you published your choice publicly. Not just your reasoning, but the raw decision itself, posted where your colleagues, your family, and people you respect would see it. If you flinch at the answer, you've got your signal. That flinch is the part of the evaluation that matters more than any risk matrix ever gave me. I learned this because I was forced to. Around 2019, our company was sitting on a decision to delay a security patch for a vulnerability in one of our dependencies. The engineering team had numbers showing the exploit probability was under 0.3 percent given our architecture. The finance side had numbers showing the cost of downtime during a critical rollout window. Both sides were right. The policy manual had nothing specific about dependency risk tolerance thresholds. I sat in a meeting where we went back and forth for two hours using data that pointed in opposite directions. Someone finally asked, "If this goes wrong and your kids ask you why you didn't apply the patch, what do you say?" We applied the patch. It took six hours. Nothing bad happened. But the question itself was the real decision tool, not the numbers on either side.
Here's the counter-intuitive part most people miss. Conscience doesn't mean doing whatever feels good in the moment. It means doing whatever you can actually live with when the temporary relief of a convenient decision wears off. Most people conflate the two. Convenience sounds like conscience until it doesn't. The difference is that conscience has a longer memory. It tracks outcomes months later, not just hours later.
How to Actually Use This Without Wasting Time
The version I use has three quick checks. First, the privacy test: would you be comfortable documenting this decision in a public incident report. Second, the role reversal test: would you accept the same logic if you were on the receiving end. Third, the repetition test: could you justify this choice if someone made it the same way every single time going forward. These take about ninety seconds each when you're practiced at them. They take longer the first few times because you're not used to being honest with yourself. The repetition test is the one that catches the most problems. It's easy to rationalize a one-off exception. It's much harder to rationalize making that exception every week. When you push the decision through a repeatability filter, you quickly find out whether your reasoning is actually sound or just convenient for this specific instance. I've caught myself on this one more than once in code review situations where I wanted to skip a step because the deadline was tight. The repetition test forces you to consider whether skipping that step next time, or the time after that, creates a pattern you'd still be proud of. Another thing nobody tells you about this process: it works best when you do it alone first, then bring it to a group. Group conscience is real, but it gets muddied quickly by social dynamics and hierarchy. If you run the decision through your own filter before anyone else speaks in a meeting, you have a clearer baseline. Otherwise, you're just mirroring whoever has the loudest voice or the most seniority. I started doing this intentionally after watching a junior engineer nod along with a decision she clearly had reservations about. She came to me afterward and told me her conscience flagged it, but she didn't feel safe saying so in the room. That changed how I run meetings after that.
Get the Full Details
Where This Actually Fails
Conscience is not a universal solution. It breaks down in a few well-defined scenarios, and knowing those helps you avoid over-relying on it. The first failure mode is when you don't actually know what your conscience is telling you because you've spent so long suppressing it. Some people, especially in high-pressure environments, train themselves to ignore that internal signal until it's just noise. If you can't hear yourself over the urgency, the filter is useless. In those cases, you need a formal decision framework instead, like a weighted scoring model or a pre-agreed escalation path. The second failure mode is when your conscience is misaligned with the actual ethical standards of your field. Personal morality and professional ethics don't always match. A developer might personally feel uncomfortable shipping code that collects minimal data, while the industry standard considers that acceptable and regulated. Running that through a conscience filter could cause you to make worse decisions by industry standards, not better ones. The third is when there are too many stakeholders with different moral frameworks. Consensus-based conscience is a contradiction. In those situations, you need a governance process, not a gut check. There's also a time cost that people underestimate. Conscience-based decisions are slower than autopilot ones, especially when you're trained to rush. In a fast-moving incident response, spending ten minutes on ethical review might cost you twenty minutes of downstream work. The tradeoff is usually worth it for strategic decisions, but not for tactical ones where speed literally prevents worse harm. Knowing which category a decision falls into is its own skill.
A Real Example From My Work
Last year I was consulting for a healthcare startup that wanted to ship a feature allowing patients to share their health data with third-party wellness apps. The technical implementation was straightforward. The legal review was clear. The product team had traction from enterprise clients who wanted this integration. Everyone in the building thought it was a good idea. I ran it through the three checks anyway because something felt off, and I was paid to notice when that happens. The privacy test flagged it immediately. Publishing the decision would read like we were treating patient data as a commodity to unlock revenue. The role reversal test was brutal. If I were a patient and a doctor shared my records with an app I never asked about, I'd feel violated even if it was technically consented. The repetition test revealed the biggest problem. If we shipped this once, we'd ship it again with looser boundaries next time. The feature went into a holding pattern for three months. We redesigned it with explicit per-app consent gates, a data minimization layer that only shared the specific fields each app needed, and an audit log that patients could view. Shipping took longer, the feature set was smaller, and the enterprise clients were initially frustrated. Six months later, a competitor launched a similar feature without those safeguards and faced a class action lawsuit. Ours didn't. Not because we were smarter, but because we actually sat with the discomfort long enough to let it shape the product. The key insight here is that conscience works as a leading indicator, not a corrective one. If you only apply it after something goes wrong, you're not using it. You're using regret. The whole point is catching the problem before anyone else sees it, and that requires treating your discomfort as data rather than as an obstacle to efficiency.
Building the Habit
You develop this the same way you develop any judgment call: by practicing it on low-stakes decisions first. Start with things where the consequences are real but not catastrophic. Choose a vendor, pick a tool, decide on a process change. Run it through the three checks. Track whether your conscience was right. Keep a simple log of these calls over a year and you'll start seeing patterns in your own reasoning, which is more valuable than any external framework. You'll notice which decisions make you uncomfortable for the right reasons and which make you uncomfortable because you're avoiding hard conversations with people. Most organizations don't teach this because it's harder to standardize than a policy. Policies can be audited. Conscience can only be cultivated. That's why people who rely exclusively on rulebooks tend to freeze when the rules run out, while people who practice ethical reasoning independently tend to navigate ambiguity better even when they don't have a perfect answer. The gap between those two approaches shows up clearly in incident postmortems, budget debates, and product roadmaps. I stopped trying to convince my team to adopt this as a formal practice after the first time someone asked me for a step-by-step checklist. The moment you try to systematize conscience, you've replaced it with something else. The best you can do is create conditions where people feel allowed to pause and actually think about what they're comfortable with. That means leadership models the behavior, meetings have time built in for ethical review, and the answer to "this is how we've always done it" is treated as insufficient without additional justification. It's slow work. It doesn't have a dashboard or a success metric you can put on a slide. But the decisions you don't have to apologize for later are worth more than the speed you save by skipping the pause.
