I've built several eCommerce back-ends, for example, and they each had a ton of very specific rules that were unique to the businesses, the products they sold, and the type of customers the services targeted. If you want to know precisely how the site validated address and credit card information, you'd really need to check the code. However, you could certainly say (and market) that you provide security measures to prevent fraud.
The snag to avoid is attempting to document the specifics of the rules anywhere but the code itself.
I.e. right now the only way a new developer can find out that we create invoices upon campaign deactivation would be by doing search in project files for instances where invoicing module is called. Is it possible to have some auto documenting system which could list all files w/ line numbers where specific function is called?
This assumes, of course, that the application is well designed, continually refactored and well tested. Every app has skeletons in the closet, though, and this perfect world often leaves something to be desired.
If your code is relatively clean though, you'll have one and only one place where you instruct an account to be invoiced, and you can trace through that code anytime you have questions about how that scenario works.
Suggestion: Every time you go diving into the code to investigate some scenario and wish to discover the business rules, start by writing a test for it. Write tests that expect that behavior, then execute the scenario and ensure your tests pass. Better yet, write those test first and you're all the way there. :)
Every business of a certain age has more business rules than any one person can keep in their head at one time. These rules manifest themselves in your code. They are the business rules. Everyone has their own opinion on what the rules are, but the developers know the answers are in the code, not in our foggy memory.
Now that we know what business rules are and where we keep them, we need to think about how we organize them. Instead of a business problem, we have a technical problem. Organizing 'business rules' becomes organizing software. This is a well-worn field, so you'll find lots of good advice on domain-driven design and the organization of software (object-oriented or otherwise).
A related software principal here is 'tell, don't ask' (http://pragprog.com/articles/tell-dont-ask). This is especially important in environments with lots of conditional rules, which must be considered at various times.