I just recently started with a new employer and have to choose my benefits – healthcare and so forth.

This is a normal event for most people. And most systems are built to handle this scenario just fine.

The company has also just announced that the benefits provider is changing. Again, this is a common enough event that systems should handle this without complaining.

But then you mix the two. Before my original selections are processed I need to change my elections because they’ve already changed. This is something that broke ADP’s system.

I can look at this from two different points of view. 1) They should make the system smarter. 2) The system just needs to handle the common cases and delegate to people when things get out of hand.

At Insurance.com we would always pick #1. The problem with is the number of cases you need to deal with skyrockets. And every case can interact with every other case. The coding is nearly insurmountable. The testing is even worse. You can build a system that you think works, but you have no way of proving that it’s working. You can do TDD to your heart’s content, but you can never account for all of the business rules and the interactions. (Ok, I guess you probably can, but never on time)

Option #2 seems like a cop-out. And it is. But it’s a safe cop-out.

Trisha has to spend a little bit of time on me and some other folks and manually set things up. Then it’s working. And we’re all happy.

How is that more efficient? Well, for one instead of spending weeks dealing with one set of business rules to figure out all permutations the system just punts. The empowered business owner, can make a game-time decision to set up things the way they should. She knows everything (more than a programmer can ever hope to know about a specific situation) and doesn’t have to ponder every possible set of cases — just my case. She decides, and it’s done.

The problem with #1 is that even if you nail all the rules, they keep changing and evolving. As things get even more complex (systems rarely get simpler over time) the possible interactions keeps exponentially going up. The rate of change commensurately keeps going down.

People are better at dealing with these poorly defined things than a program. People can make a snap decision, programs have to try to meet a deployment schedule.

Sometimes being in the middle of it can be frustrating. It can take longer and you wonder why the person designing it messed up and didn’t handle your case. But sometimes it pays just to have the smarts of a real-life person at the wheel.

Simple repetitive things are for computers to solve. For complex one-offs, I like to trust a person.

She’s on top of things though. In the end I know my benefits are set up right because a person made sure they were.