The regulatory environment dictates that hospitals who contract with physicians meet specific conditions in order for the contract to be legal. The conditions are meant to ensure the physician payment is not based on volume or value of business because it can lead to overusing services and increasing overall costs of care. Technically violating your own contracts can lead to multi-million dollar settlements.
For this reason, physician contracts are super complex. Great detail is spelled out in these agreements to make sure it is legal and documentation is necessary each step of the way. These physician contracting errors are technical violations of Stark Law. Essentially, if you break the rules of the very specific contract in place, you are at risk. Said another way, operationally the rules of the contract must be followed day by day. These errors that are pretty easy to avoid with the proper processes, people and structure.
The first is that physicians are paid for duties that are not spelled out in the contract. Because the contract must clearly spell out the duties, it seems logical that it would be easy to make sure this is in scope. The problem is the process of the physician hand writing a duty, from memory, can lead to either a duty that is too vague or simply not in the contract. The physician initiating this document is not a safe process because they are busy and don’t look back to their agreements to write duties word for word. This can lead to working on things that are not part of the agreement or simply documenting the activity insufficiently. The best way to avoid this potential error is to have the physician first select a duty from the contract when logging a time entry, then make a specific note. Respecting the physicians time and making it easy for them to provide the hospital with the needed documentation is preferable to a blank piece of paper.
The second error that is all too easy to make is that conditions of payment are not examined when the payment is being made and missed. For example, a physician submits a time log with 12 hours of work for a particular month. The time log is approved by 4 people, a check request attached and the physician is paid. Yet the contract said the physician will not be paid for more than 10 hours per month. Unless there is a process in place for each payment to be checked against the terms of the contract, this can happen all too easily with the best of intentions. The best way to avoid this error is to use financial payment software to identify any contract conditions and to stop payments when appropriate.
The last error paying the wrong party, which is also a technical Stark Law violation. This is seemingly very straightforward yet oddly difficult to follow in practice. An example is, the contract for a medical directorship is between a hospital and a physician practice, the legal entity of the physician group. The work is done by a particular physician, he hands in a time log and the check is written directly to the physician and not the entity. The law is strict, if the contracting party is the physician practice, the check must be paid to this entity.
In all cases, the paperwork is very clear for how this contract should be fulfilled. The problem is in checking each time log entry, hour, dollar amount, contracting party, etc., against the contract. In practice, the specifics are too many to trust to people and their ability to remember the specifics or to manually check each time a payment is made. Set your contracts up for success by putting in place software, processes and assign accountability to avoid physician contracting errors.