Understanding Medical Revenue: Where It Comes From and How to Optimize It
What Is Medical Revenue—and Why It Matters Medical revenue isn’t just a line on a report—it’s the lifeblood of your […]
Leadership
What Is Medical Management? A Clear Guide for Physicians
Running a medical practice today involves far more than just delivering great patient care. From managing staff and navigating complex
Medical Practice Management: What It Is and Why It Matters
Running a medical practice is about providing excellent care, but it’s also about running a business. And for many physicians,
How to Create a Culture of Accountability in Medical Practices
Accountability is one of the most important—yet most misunderstood—elements of a successful medical practice. At MedMan, we often work with
When They Ask for a Raise
[fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">Scott Tucker Pt 2_When They Ask for a Raise: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2022">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">Scott Tucker Pt 2_When They Ask for a Raise: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2022">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in, and we hope you enjoy today&#39;s program.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Hello and welcome to the Medical Management podcast, I&#39;m your host, Jesse Arnoldson. I am rejoined by my good friend Scott Tucker of Women&#39;s Health Associates in Boise, Idaho. Welcome back, Scott! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Thank you. Glad to be here.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />We are glad to have you here. Today, we are going to get into one of the most, I think, one of the more common interactions that managers have with staff on the topic of pay raises. And so I set this up for Scott to think about what happens when the nurse or the receptionist comes and says, I think I deserve or I want to ask for a pay raise. I think a lot of us don&#39;t have a good plan for that, and no plan is still a plan. It&#39;s a plan to flounder and either negotiate poorly or make the employee leave unhappy or give them more money than they should. So tell me a little bit about your approach to when you&#39;re asked about pay raises.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />So I think the biggest thing and a lot of this has been through the school of hard knocks, but it first thing I can say is just make sure you have your facts. So. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />I know you&#39;re, I, I watch the market value, fair market value for all of our positions, at least semi-annually, usually especially over the pandemic, because it seems like they were changing monthly. I was watching ..., I keep those ranges so that I kind of know where everybody&#39;s at. And one way to kind of curb off people asking for a raise or feeling like they&#39;re being underpaid is I make adjustments throughout the year, so if the market shifts up and some people are not within market range anymore, then we adjust them. I will say during COVID, I didn&#39;t do a quarterly because they were going up and down, but it seems like things are a little more stable right now, but I have a feeling it&#39;s going to change as we&#39;re, we&#39;re all experiencing with the generation of resignation.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Mmhmm.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />What that does, and even if everybody isn&#39;t getting adjusted because of market changes, let&#39;s face it, they all talk and so they know, they hear it. They know we&#39;re watching it, they know we&#39;re, we&#39;re making the market changes, so that&#39;s, I think the first kind of proactive step we can do. The next is really just making sure you have your facts available so, not only market range, but also look at it, all of the benefits that you provide that you&#39;re providing on the employee&#39;s behalf and they can be everything from PTO days to paid holidays to paid breaks, in-office services, health insurance, retirement, all of those things that have a dollar value associated with them, those are big numbers you need to have. And the approach that I then take with people is if we ask, if they&#39;re coming and feeling like they deserve a raise, we talk through it, I want to hear them out, let them explain what they&#39;re feeling, why they&#39;re feeling the way they&#39;re feeling, and have them give you a number because a lot of times it&#39;s why just think I need a raise? Ok, well, how much? I don&#39;t know, you need to figure that out.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, right, right. No, no. Wait a minute.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />That&#39;s not how it works.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />And then the next step of that is asking, where are they getting their numbers from? And it&#39;s usually, well, my friend says this and they work here.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />OK, great. So let&#39;s go through it and I have this exercise that I take people through. Ok, let&#39;s look at your hourly wage, and then let&#39;s look at health insurance, so we cover X amount for you, over here what does that look like? Oh, you have to pay one hundred dollars a paycheck? Ok, so there&#39;s money right there. You know, in-office services we, we have, part of our employee benefit plan is a certain dollar amount attributed for each each employee to get in-office care. Well, that has a dollar value to it. And so then, what I do is I go through this whole step with them and we set things out side by side, so then they can really compare and look at, and because those have dollar values to them, you can then back them into what it equates to per hour based off the hours they work and. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />So they have to come back to that language, right, Scott? Like it has to come back to the hourly language because that&#39;s what everybody understands and who goes off of. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Right, absolutely. And so we can attribute that to, yeah, you&#39;re you&#39;re making x dollars an hour, and while you might make the latest one that came and talked to me, she was going to make seventy five cents more an hour. So I said, OK, let&#39;s, let&#39;s look at that. What it really came down to when we went through and compared truly apples to apples and the benefit structure and everything, she still makes three dollars and fifty cents more an hour here than what she was going to make at this other clinic, but it was enticing because I&#39;m going to make seventy five cents more an hour. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right, right. But at the end of the day, man, the paycheck doesn&#39;t go as far.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah. And then. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />For some reason.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />So that next step of, well, I&#39;ll have more money in my bank. Well, let&#39;s break that down because for health insurance, you&#39;ve got to pay this. We with a 401(k) plan and with pre-tax allotments that we do for part of our benefit plan, I also back out and show them that we reduce their taxable income, which actually gives them more money than just getting seventy five cents an hour and going through those steps with people, and, and you just find that most of them just never put two and two together, they just hear the hourly thing and then that&#39;s all they&#39;re focused on. Will I make x dollars an hour and over here I can make 50 cents more a dollar more, even two dollars more, but not really comparing everything that goes into it. And the other piece that I find when going through this exercise, I have yet to be where we&#39;re under, we&#39;ve been close, fortunately so it tells me we&#39;re still doing good, but it also opens up their eyes to how much it costs an employer to have an employee. They just think, well, no, you just pay me my wage, you know? And so we&#39;ll also go through the exercise as well is showing, well, here&#39;s how much the employer taxes are, here&#39;s how much worker&#39;s comp is, and while this doesn&#39;t go into your compensation, these are the expenses that the employer has, so when you&#39;re talking about 50 cents an hour, this is the downstream of what it really turns into for an employer and. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Just trying to open up their eyes to how employment works. And it&#39;s not just about paying X number dollars an hour. So you&#39;re really trying to. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Not many people understand that. So it&#39;s good to bring them into the, into the know. Do you have, Scott, do you have a philosophy of what it does take to get a raise. Like, let&#39;s say, let&#39;s say somebody comes in and says, look, I, you guys pay fair market value, I feel like I am better, I am at a higher level than what you&#39;ve put me at.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Or I deserve a raise because I&#39;ve been working really hard.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Absolutely. So the way we approach it is we have just pay bands, so entry level to the upper echelon and a lot of flexibility within those pay bands. And we give credit to a medical assistant that also manages all our supplies and inventory, that&#39;s above and beyond work. The other thing that, that we&#39;ve done is we&#39;ve tried to break down, even though the medical assistant role is a medical assistant role, we&#39;ve kind of even broken those into categories based on general roles and responsibilities, if they focus mainly on patient intake and rooming versus patient intake, rooming, and calling with lab results and whatnot, or they take on extra roles like supplies or QI stuff or for those kind of things, take those into account and then give some compensation there. As well as we feel there&#39;s a lot of value in people&#39;s previous experience and putting. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Maybe a little heavier weight than some places would consider. And that&#39;s just to attract experienced qualified staff. And we want to recognize that if they worked, you know, out of state and a specifically like W.J. and a women&#39;s health office, there&#39;s, there&#39;s value to that that they should they get compensated for.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Absolutely. Can I share with you? You know, this is just an example, but I&#39;ll show the example I put in a couple of different clinics of, well, what does it take to get a raise? I think I have three reasons. One, would be your normal annual because I think there should be a ..., because it just gets more expensive to live every year. Two, would be if your job changed drastically, you know, like if we were going to add the above and beyond stuff that you talked about, or let&#39;s say we moved somebody from reception to care coordinator or from nurse to lead nurse, we&#39;re going to add money to that. The third one would be the market value. You know, our pay scales, fair market value, and if we put you fairly in the right spot in those scales. And I try and have those ready like they&#39;re just simple rules, simple ways of doing it because you&#39;ve got to have an answer, because if you, if you fumble and then end up not getting it, the impression is, well, we thought about it and you&#39;re not worth it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Absolutely.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />That&#39;s so bad. That&#39;s why most people, most people&#39;s experiences, I ask for a raise, I get told no, I&#39;m going to go elsewhere. And that is the risk that I think people, these managers, they need to have a plan because it&#39;s not just a one off conversation, can I get through this awkward conversation and get to the other side of it, and I&#39;ll be OK? No. This is a very high risk moment where the person could turn over, if you do it wrong. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />It&#39;s actually, right now in the current environment of leaving and whatnot. I think the other piece, as we were talking about earlier, when you start the conversation with explain to me, you know, kind of what you&#39;re thinking and where you&#39;re feeling you&#39;re being under compensated. And what&#39;s that number that puts that? It sounds bad, but it puts it back on them and then they&#39;re engaged in that conversation and it gives you time to react. It gives you time to get a sense of where everything is at. If they come and say, well, I feel like I, I&#39;m the one you hear the most well, I&#39;m good and I&#39;m loyal, Ok. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />You&#39;ve been here for a year, so, and that&#39;s not with five dollars an hour or more. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right. Oh my goodness, I love that. I need the one that I had that probably bugged me the most because somebody came in and they were very genuine, they were very sincere in what they&#39;re saying. So, you know, I&#39;ve, I&#39;ve worked my butt, I&#39;ve worked really hard, and if I had and I don&#39;t say this in my head, I go, well, if you had it, I didn&#39;t realize that I could have come back to you and said, hey, we&#39;re going to pay you less. Oh, and that&#39;s just the jerk side of me, and I keep that very much suppressed inside. But I think my explanation to that person was, you know, working hard is the prerequisite to just staying here, like that is, that&#39;s what it takes to keep your, stay employed here. And we&#39;re going to make this an awesome place to work so that you want to be here, you want this to be your place of work and not on the assembly line of doing frozen chicken meals, you know, we want you to enjoy it here. But just because did your job well, that&#39;s not, that doesn&#39;t fit into the rules, like this philosophy, here&#39;s the philosophy, let&#39;s, let&#39;s figure out where to sit. I didn&#39;t come out on top of that conversation. The person ended up leaving, so I probably did say something offensive, well. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />I think to add on to that, that&#39;s that&#39;s where your, you can lead them there without having to tell them. And that is what additional things have you provided outside of your normal, normal everyday function?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Are there other things that you want to do?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You want to take on more responsibility because I&#39;m all about it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah, absolutely. And I think that&#39;s the key and especially with the generations we&#39;re seeing now is, you know, not, not in a negative way, but they just don&#39;t know, they don&#39;t get it. This is a foreign concept to kind of a deep understanding of what goes in to make the wheels turn. But more importantly, is and you know, we saw it in our previous podcast talking about the No Surprise that they&#39;re very much into this. They want to have more details than what, maybe, historically other generations did. So we have to adjust to that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It&#39;s an informational, only that we were in the industrial age, now we&#39;re in the information age and people want, they want to know.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah, absolutely.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And I want to, you know, to the point they made earlier, Scott, that people talk. I think that it always been good general practice to pretend that if everybody&#39;s pay was posted on the break room fridge, would you look the people in the eye and justify why they make what they make? And I&#39;ve been in some clinics where I couldn&#39;t do that, you know, maybe it had been set a certain way that I didn&#39;t have much control over and, or maybe in my younger years, maybe I gave more money to people I like, I can admit that. But now I sure as heck have documented, OK, I gave Scott, you know, an extra 50 cents because he speaks Spanish, that I gave him two dollars for his degree and I gave him five dollars for his experience.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Perfect. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />That&#39;s how it goes, and you can, to another appointment you made, you can bring in applicable experience. I&#39;ve given money for experience outside of health care, customer service. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Absolutely. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Call center work, any, anything like that that can be added on to kind of help, not to give away the farm, but to make, make somebody know their value and to show that. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Oh yeah, I think that goes into more talking a little bit earlier and just historically with pay scales, you know, there was this shift for a while and I get it, it really helped with kind of the times we were in, but it was like, OK, you&#39;re in this position with this degree and this is your experience, this is what you make. So very black and white. Just pull you size on a chart and go in there. And while that has some benefits to it, especially when you know to your point about, well, if everybody&#39;s pay was posted, how would you feel, happy to defend that? That&#39;s easy. Here&#39;s the pay, here&#39;s where you sit. The downside of that is the people side of it, which is it doesn&#39;t account for things, it doesn&#39;t account for oh, you speak Spanish, or you know, you&#39;ve got 10 years in a call center, that plays a lot of role into what you&#39;re doing in our phone center and. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Just kind of thinking, and then. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Could you make it match, though? Because that&#39;s I mean, you and I, we built our pay scales off the same foundational stuff, right? Like ours are very similar to each other of how it&#39;s put together. But I put language, I put, I got, what, did I put? Language, education, general experience and then directly applicable experience, I think those are the four categories that I gave more money for. So if you worked at a call center, you got a certain amount of money, if you worked at the pediatric clinic down the road on the same EMR, holy moly, you know, you hit the jackpot.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />Yeah, no, absolutely. But I think that&#39;s where it, having some subjectivity to it is exceptionally helpful. And that also helps you, for the staff member it helps build a little more of that personal touch as opposed to just being another cog in a wheel that, this is where you are, you know, especially with the generation we have, you know, 50 cents an hour is the, you know, I&#39;ll leave a job over 50 cents an hour without knowing anything else into it. So we&#39;ve got to remember that, we&#39;ve got to somewhat play into that and understand where the mindset is and how we can best educate and explain and provide that information for them to make an informed decision. And if they end up leaving because of it, you know, at the end of the day, then we also know that we did everything we could and it just wasn&#39;t a good fit.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly. No, I love it. Scott, thank you for your insight and for your your ideas and advice. I know it&#39;ll be of help to a lot of people. And you&#39;re welcome back any time. And for all of our listeners, thank you for tuning in, please make sure that you take this subject seriously because it&#39;s a high risk situation where you quite easily could be the last straw that kind of pushes that employee, good employee to turn over, and that is not what we need in this time of, Scott, what did you call it? The generation of resignation. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Scott Tucker: </strong><br />The generation of resignation. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Definitely don&#39;t need any more reason to have to be, in recruiting more than you need to. So guys, for anything that MedMan does, the show notes to this episode and any other, please visit us at MedMan.com and we&#39;ll see you next time. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guests. For the show notes, transcripts, resources, and everything else, MedMan does to help you level up, be sure to visit us at MedMan.com.</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="world-class support" target="_blank" href="https://sonix.ai/features/world-class-support?utm_source=embed">world-class support</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="secure transcription and file storage" target="_blank" href="https://sonix.ai/features/security?utm_source=embed">secure transcription and file storage</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="automated subtitles" target="_blank" href="https://sonix.ai/features/automated-subtitles?utm_source=embed">automated subtitles</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="powerful integrations and APIs" target="_blank" href="https://sonix.ai/features/integrations?utm_source=embed">powerful integrations and APIs</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="kepdmwjgFQ9yccWYkz1szg14" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","https://sonix.ai/widget.js","https://sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->

[/fusion_code] Episode Summary Welcome to the second episode with Scott Tucker! This time, Scott joins us to chat
Top 21 of 2021 – Favorite Things for Wellness, Leadership Development and Productivity
[fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">Medman_Lauren Harris Top 21 of 2021_Favorite Things for Wellness_Leadership Development and Productivity: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2021">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">Medman_Lauren Harris Top 21 of 2021_Favorite Things for Wellness_Leadership Development and Productivity: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2021">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in and we hope you enjoy today&#39;s program.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Hello and welcome to the Medical Management Podcast. I&#39;m your host, Jesse Arnoldson. I&#39;m joined today by a dear friend of mine, Lauren Harris, who is the owner of Harris Healthcare Consulting. Lauren is also actually the institutional liaison for women in healthcare for the Oregon chapter. Welcome to the podcast, Lauren! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Thanks, Jesse. I&#39;m delighted to be here.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I&#39;m so excited that you&#39;re here. Lauren and I have been dear friends since 2019-ish, where we met at. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Sounds exactly. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, we met at the State Leadership Council for MGMA when we were over in Denver, right? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes, that&#39;s true.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />You hadn&#39;t broken off on your own yet, had you?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />No, not yet. But I was really excited to talk with someone who considered themselves a consultant and was still part of MGMA, and I wanted to do that as my dream job. So that&#39;s why I sought you out that day.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Tell me, Lauren, after that, what finally helped you get over the hump of going out on your own and being a consultant and earning your own bread, right? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Hmm. Well, first I went from a corporate clinic manager job to joining a local consulting firm, a small group, and sort of learned the ropes that way, but decided after about two and a half years there that what I really wanted was to own my own business and to be in charge of my own client list and my own workday, and so I did that in, right in the middle of the pandemic, July of 2020.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />What a time to be alive, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And to go out on your own. One of the things I love about you, Lauren, is just the way you view the world is through just a lens of positivity and, you know, not getting down on anything. There&#39;s a silver lining somewhere. Tell me a little bit about what the pros have been of starting your company in the middle of a pandemic.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Wow. I think the, one of the things that comes up for me is that there&#39;s such a need that practices, that I feel passion to serve, the private practices out there in my community really need support and that practice administrators really need support. And having done that job for many, many years, I understand how lonely it is and I understand that just having someone else that you can reach out to to do extra projects or support you in some way can help you get through the day. And so I think, I trusted that the need was there, and I also trusted that if it wasn&#39;t, I would go get a job somewhere else and I was going to be OK.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, that&#39;s what I&#39;m talking about. There&#39;s that positivity. Tell me just before we jump into our main topic, just one more quick thing, Women in Healthcare. Tell us a little bit about that organization.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Sure. So Women in Healthcare is a national organization that started back east and launched an Oregon chapter I think about two years ago, but I&#39;ve gotten introduced to the group probably nine months ago or so. They were looking for board members and they were coming out of what they call the incubation stage into the growth stage. And I saw the opportunity to join another community that was still healthcare-focused, but that also had a real lens on diversity and inclusion. So the way that they positioned themselves are, if you identify as being in healthcare and you identify as a woman, you are welcome to join us. And I have just loved the connections that I&#39;ve been able to make there that are different from the connections that I made in the practice management world over the first 20 years of my career.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />What kind of, what kind of people are there, what kind of professionals, what are they in?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So there are some in healthcare architecture. There is, of course, C-suite level of all the large health systems involved as well. It&#39;s really every type of role you can imagine. I remember being really surprised by someone who did healthcare landscape design, and when I stopped and thought about it, yeah, somebody makes those healing gardens of hospitals, who does that, you know?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So there&#39;s this whole sort of industry that&#39;s outside of the practice management world that I&#39;ve been exposed to the first part of my career that I really wanted to know more about. So I&#39;ve gotten to be connected with women who serve in all kinds of health care roles, both on the board and just members that attend our regular events.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love it. That&#39;s so cool. I love it so much. Well, for our listeners, Lauren and I got together a couple of weeks ago, and we&#39;re kind of thinking about what we could talk about today because I knew that we wanted to have Lauren on the show, that something good would come from it, and the idea that we came down on was a top 21 of 2021 tips, tools, and techniques, our favorite stuff that came out almost like an Oprah&#39;s favorite list, and things that focus on wellness and leadership development and productivity just to kind of cop-out, we&#39;re coming to the close of a year and there&#39;s just so much good that has come out of it, that we want to focus on. So we&#39;re going to get into this and kind of dive into 21 really solid, like I said, tips, tools or techniques that will help any professional. So let&#39;s jump on in. Let&#39;s jump into the, well, the topic of wellness.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Sure.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />So what&#39;s your first, Lauren&#39;s favorite that you want to talk about?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So I started subscribing to the Calm app this year and really bought the paid subscription, jumped in with both feet. And what I&#39;ve learned is in addition to the meditation part of it, there are these sleep studies or stories, rather, so sleep stories where someone reads to you as you fall asleep and it is the most soothing, amazing, relaxing experience and at the same time, frustrating because I can&#39;t think of a single story I&#39;ve heard all the way through, they do such a good job. It is just something super soothing, I guess, about the experience of being read to. So I&#39;ve learned some meditation tips and tricks through the Calm app, I&#39;ve also really enjoyed those sleep stories, and then there are music playlists, too, that you can have in the background so it can, Calm can be used during the day, it can be used as you&#39;re falling asleep at night. It&#39;s a wonderful app that I really enjoy.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love that. Let&#39;s move to number two.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Sure. So the second thing that I wrote down on our list is that you should work in a space that makes you happy. And what resonates for me is several months ago, I moved out of my home office into a real office, and I was able to create a space that is all mine, and I realized that over the years, I&#39;ve always taken up space in someone else&#39;s office or work in someone else&#39;s space. And you know, you have to sort of adapt to the furniture that you inherit or whatever it is. And here I was able to make this a space that makes me feel good about coming to work every day. I&#39;m proud to let people see it in the Zoom video call behind me.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, yeah. You don&#39;t use, you don&#39;t use the. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Blurr the backgrounds anymore?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Anymore. Yeah! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />No. And as much as I love my dog and my cats, they don&#39;t show up on the screen anymore, which is great for those calls. It just keeps things a little more professional. But I think it&#39;s, it&#39;s incredibly valuable to have a space that makes you feel comfortable and happy and to work from that, however you can.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I agree, and it&#39;s been kind of fun to watch, you know, as we have gotten on Zoom calls over the last six months, and seeing you move your stuff in and making it more yours is awesome. Well, I know, I know for myself or like, with the five kids I have, if they get into the office and they do, I can come down one day and it&#39;s just in pieces. You know, there&#39;s paper everywhere, there&#39;s candy on my desk, there&#39;s all sorts of stuff all mixed up, and I have caught myself many times just being like, nope, and I&#39;ll take my laptop and I&#39;ll leave and I&#39;ll go somewhere that makes me happy. And so there really is something to getting the area around you to support your best working self, I think. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah, there is, there is. I have a board. It&#39;s a little sort of corkboard that I can see when I&#39;m on my call, but others can&#39;t see, and it&#39;s sort of thoughts and quotes. It&#39;s things that mean something to me and one of my favorites that I picked up from Joe Schmo, who will talk about a little bit, is my agenda aligned with my values. And when I get stuck sometimes or I&#39;m not sure what to work on next and I think about feeling overwhelmed, I use that as just a quick reminder, am I on the right stuff? Am I working on things that align with my values right now?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, no. I love it. I love that. Well, good. Let&#39;s keep moving through the list.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Okay!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Number three. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Number three. So I put on here, be comfortable. And I turned 50 last year. The same year that I started my business, I decided that I was no longer going to try to conform to Western American society thought I should look like or dress like. And by that, I mean, I stopped coloring my hair, I embraced my gray, I stopped trying to dress up for occasions where I was incredibly uncomfortable, so I rode on to here with my shoes. I switched to wearing what is comfortable and really appropriate for my needs.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And then, of course, we all went virtual anyway. So no one can see me what I have on my shoes.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Nobody&#39;s even seen your shoes.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />But when I do go to clients and visit with practices, I no longer worry about wearing high heels, I just wear what works for me, and I am embracing others in their diversity and I expect them to do the same and it&#39;s gone really well.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Nice! I love it, love it, love it. Speaking of which, that kind of leads us not well into the fourth one.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah. So I also wrote down, something I&#39;ve learned this year to embrace more is honoring and looking for diversity. And when I think about that right now, a lot of us are recruiting and we&#39;re trying to find new members of our teams, and a tip or a technique that I heard that I thought was brilliant was to partner with someone else when you&#39;re recruiting and have them blank out the name on the resume before they hand it to you.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Then your unconscious bias around gender or around race or anything else that might come up from your assuming something about that person&#39;s name is gone. You can no longer do that. You&#39;re now looking just at the qualification. And if you sit with that for a minute and really do that for yourself, you might be surprised at the unconscious biases that you have. So that was one of the things that struck me, and I&#39;m trying to do that now when I do recruitment for others, is to really ignore or even white out the name that&#39;s at the top of the resume and just go on the qualification.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I like that, I like that. For me, a version of that that I was doing when I was in the clinic in recruiting was that I stopped having, I would do a phone interview first, you know, there are lots of other motivators for doing that, but one of the unintended benefits was I would get the chance of just being able to hear them talk and see what they were like, you know, just chatting. Could they be a good human being? And I would never have their resume in front of me, you know, and I would try not to let any of that go because a lot of the jobs that I was trying to get to were, I needed them to just be good people. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Have a nice conversation with someone on the phone.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes. Yeah. So and so whether their experience, all this kind of stuff, yes, I&#39;d have to use some of that to, you know, to decide I wanted to talk to them on the phone. But then after that, it really was up to whether they, how it went in the conversation, yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />I love phone interviews first. I think so many of the jobs that we&#39;re hiring for, pretty much everything, has some level of communication with the outside world.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And can someone do that in a way that&#39;s professional and warm and approachable and represent your business in the way you want to be represented? It&#39;s a perfect test for that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly, exactly. Well, let me take number five, as far in this wellness topic. A big improvement for myself and for a number of my friends that I&#39;ve talked to recently has been to find a good counselor, somebody who matches up well with you. I always took it as a joke, I had a professor who had worked in healthcare administration for decades and, you know, as we were talking about what it would take to be successful, he said a good psychiatrist and, you know, I laughed it off because it was coming from a place of cynicism and because he was so burned out from the industry, but I have realized so much more that yes, you can use a good counselor or mental health professional to help fix some issues if they&#39;re there and you shouldn&#39;t feel bad about that, but also to proactively just do better, you know? And so as I&#39;m trying to round myself out and do a little bit of exercise and eat a little bit better and put my phone away when I, you know, when I&#39;m home, it fits. Having a good counselor fits into my goals of just being more well-rounded, healthy. I don&#39;t know if I said that, if that was all good English or not, but yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Absolutely. Our mental health is no different than our physical health and we need to pay attention, especially now. I think we&#39;ve all been feeling incredible amounts of stress in new and different ways.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It&#39;s manifesting itself in new and different ways and talking to someone who has the techniques and the tools to share with you, to teach you how to cope with those things is super important right now.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It is. You know what I&#39;ve learned, Lauren, is how many of my friends quietly see counselors as well. I mean.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Absolutely!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I don&#39;t know why it ever got to the point of having a negative connotation to it, but there&#39;s a lot more people out there than you think that access that kind of help. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Absolutely.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And they do better for it. So shouldn&#39;t have. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Wouldn&#39;t it be great if we could share those things we learn with each other even?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Look at this brilliant thing my therapist taught me and then I can share it with you, and let&#39;s just be open about it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly, exactly. So, you know, to cap off the wellness side, that&#39;s been one of my favorites of the year.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Fantastic. I&#39;m going to add a bonus tip for wellness because you made me think about it, okay? So I also started seeing a massage therapist.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, OK! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And I think when you think about therapy, we think about the mental health side, but also the physical side and massage therapy can be so healing and so helpful, and also gives you sort of an hour of protected space where you can just go and be and enjoy that therapy.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I love it, love it, love it, love it. Well, let&#39;s transition to our biggest topic of leadership development. I know that there&#39;s a few people that made the list. Let&#39;s jump into that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />I have so many favorites. It&#39;s really hard to pick, but I find myself continually recommending that others follow these folks, and so I&#39;m going to share my favorites. Tracey Spears of the Exceptional Leaders Lab also is an author and has an amazing online coaching masterclass that&#39;s available that I really recommend. It&#39;s all about personal and professional development, and I was just telling someone else today. Go and do it, it is at the unbelievably low price of, I think, forty-nine dollars, I mean, it&#39;s just a gift.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, wow!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Go and check it out. The Exceptional Leaders Lab masterclass with Tracey Spears and read her books.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Fantastic. What&#39;s the name of her book?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />One of the Exceptional Leaders Playbook. And I knew you were going to ask me the second one, and I have to look it up. But if you want the CliffsNotes version, just to be honest, if you do the coaching masterclass, you&#39;re going to get a lot of the greatest hits out of the book. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Nice, yeah!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And they are nicely recorded into little vignettes and tip sheets and things you can take away right now. And if you know anything about me, you know, I like those tangible things that I can do and build, so she gives those to you as well.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I love it, good, good, good. Who&#39;s next on your list?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Well, next on my list is Joe Mull. If you&#39;re not familiar, J O E space M U L L, he has a program called Boss Better Now.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Ok.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And it is incredible. So he has done speaking at MGMA state conferences for years. But when the pandemic hit, he was the one who pivoted the fastest to the technology he immediately started doing things online, he has a remote studio that makes you feel like you&#39;re absolutely there with him live, and he&#39;s giving you his best with the keynote. But my favourite thing that Joe does right now are these weekly podcasts, and it&#39;s The Boss Better Now podcast, and he has a co-host with him who is an executive coach. Her name is Alyssa Mullett and I learn and get something out of every single week. I highly recommend it. I think he&#39;s on episode forty-one or something now, so. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Nice.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />If you haven&#39;t been listening, go back, listen to them all. It&#39;s amazing, great, great stuff. And he has a background in healthcare, but also it&#39;s relevant regardless of what industry you&#39;re in.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Good. I love it, love it, love it, love it. Next would be? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />The next one is a guest that Joe had on his podcast, actually, a man named Clint Pulver, who wrote a book called I Love It Here, and it is all about research that he did as the undercover millennial, going into different workplaces and talking to people about why they like working there, pretending to want to get a job there and asking people, what&#39;s it really like to work here? And then gathering all of this data that he would give back to the business owners. And he learned and shared in his book, best practices for hiring and retaining great employees.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />The book is called I Love It Here. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Called I Love It Here, and it&#39;s by Clint Pulver.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, that&#39;s awesome. I&#39;m going to make a little note. Yeah, I Love It Here. Fantastic. I think that that&#39;s probably, oh my gosh, one of the most important things right now is, as we&#39;ve seen, so many of our clinics go through this kind of staffing crisis issue, yes, it can be about the money, but more than likely it&#39;s about you as a leader and the culture that you&#39;ve helped foster there and whether that&#39;s where people want to be or not.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yes, so much so. And I think people are no longer tolerating toxic managers, toxic workplaces, toxic anything, and they&#39;re looking for something that has value to them and that feeds their soul in a way that we haven&#39;t thought about in the past. And I think as I&#39;m helping practices recruit, being able to tell your story about who you are as a practice, what your values are, what your vision is, where you&#39;re headed, those are all selling points that will help you get people that are in alignment with you because it is so much more than the money, it is cultural all the way. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It is, for sure. Ok, let&#39;s talk about Deborah Grayson Riegel.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Okay, so Deborah Grayson Riegel is a woman that I just saw at the National Women and Healthcare Conference online. I am enamored, I just posted something on my LinkedIn that she posted, so she wrote a book which I have not read yet, but plan to, called Overcoming Overthinking, 36 Ways to Tame Anxiety for Work, School, and Life. She has many vignettes, she has LinkedIn Learning courses, she has online courses on her website that are amazing, so I really recommend looking her up as well. She&#39;s also a Wharton Business School part-time professor, she&#39;s delightful to listen to and full of great information.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />All right. I love it. I need to read that book. I know a lot of people do.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It&#39;s awesome. All right. Last on our people list. Dorie Clark.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So Joe also introduced me to Dorie Clark. So. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />OK!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Dori Clark is the author of a book called Reinventing You, which was named a number one leadership book of 2015 by Inc magazine. She also wrote another book called Entrepreneurial You, which was in the top ten business books of the year by Forbes. But what I liked about this was the concept for her new book is the long game, how to be a long-term thinker in a short-term world.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oooh, I like that. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And I&#39;m diving into that now, so I&#39;m still grabbing nuggets. But what I am thinking about so far is we have spent the last year and a half, slightly longer, focused on firefighting and the immediate and, you know, crisis, right? What&#39;s right in front of us, and we haven&#39;t probably taken enough time to think about the future for ourselves and our organizations and the long-term goals that we have. Her book is really around how to strategize long-term and to not lose sight of that as you are fighting those day-to-day fires.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I love it. That&#39;s so great. All right. Going into a non-person one. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yes. So are you familiar yet with the AMA steps forward modules?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I&#39;ve never heard of it! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Okay, so this was something else that I learned from a national MGMA conference. I happen to drop into a breakout session where someone had this pulled up on the screen. I did not know that this even existed. It is a free resource from the AMA, they are learning modules that are designed for clinicians, they have to EEUs attached to them, but beyond that, they are just tremendously good resources for all kinds of things. There are things in there about team-based care, there are things in there about prepping for visits, just workflow-related, it&#39;s everything that you might need to know to run your practice more efficiently and more effectively and free. Go to the AMA Steps Forward program and look at some of those modules. You&#39;ll be amazed.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love it. I&#39;m going to go there right after we get done recording. I have a lot of like things to add to my life. One, to-read list and need to-watch list, and I&#39;ll go to that one first.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It&#39;s a great one.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />OK!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />You&#39;ll find lots there.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Well, I think we&#39;re on number 12. Tell me a little bit about your 12th one. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So I wrote down join a network or make your own. So there&#39;s a lot of great opportunities to join networks out there. I&#39;ve been a member of MGMA State Chapters for years, but I also wanted to just express that there&#39;s no reason why you can&#39;t make your own network. So Jesse and I have been part of this ad hoc pediatric group that I put together because I realized I had four, maybe five now, pediatric managers that I regularly, or administrators that I regularly talk to, and they were all sort of operating without knowing each other or the tremendous expertise and great people that they are. So I put them together in a Zoom meeting, that meets, we meet monthly now, don&#39;t we?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />We do. We do.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And I think that we were all pediatric-based and were or going to be state MGMA chapter presidents.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Almost all. Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Almost all. Yeah. We&#39;ve added a couple since then than aren&#39;t, but like. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It was nice to have, oh my gosh, it just felt like the perfect match-up with these other folks. And I was so grateful that you pulled me into that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It is such a great organism, not even organization, it&#39;s a club, it&#39;s just a fun thing that we have. I call it a support group because that&#39;s how it feels. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It&#39;s a little support group, yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love it. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So my takeaway there is make your own. If you&#39;re not finding a community that works for you, go out and make one.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Perfect. Perfect. I love it. Ok, let&#39;s jump into number 13, crucial learning.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So crucial learning is the newly branded name of the folks who did crucial conversations over the years, and many of us got crucial conversations training in larger health systems or in other places. But I just wanted to share that they&#39;ve rebranded. They now call themselves crucial learning. They&#39;ve re-recorded many of the training videos, so they&#39;re more diverse, they&#39;re more up-to-date, they look much more modern, and they also offer some mini learning videos for free. If you subscribe just to their blog, you&#39;ll get a regular cadence of thoughts for the day and reminders about communication. So it&#39;s a really good one, too.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I love that, I love that. I can&#39;t wait to jump into that. Ok, I&#39;ve lost it, let&#39;s see, 12, 13 14, 14! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />I don&#39;t even count! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I should have numbered these! You wouldn&#39;t know. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />No, I didn&#39;t either! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />The walking time.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yes! Walking time. We definitely agree that this is important that if you don&#39;t put this on your calendar, something else will fill up your calendar and you will miss out. So scheduling appointments with yourself to do your own professional development, attending classes if you haven&#39;t seen it yet, Coursera offers college classes for free. These are the same courses that are offered at Ivy League universities or universities all around the world. You can basically audit them for free, so if you don&#39;t care about getting the certificate or getting the college credit, you just want the knowledge. Check out Coursera, it&#39;s C O U R S E R A, LinkedIn Learning also has tremendous modules, they do have a subscription model though, so there is a cost for that. I think they offer 90 days free. Do you know Jesse?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think I had an advertisement come up yesterday just for that, for 90 days. Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah. So it could be worth jumping in there for 90 days incidentally, Dorie Clark has several educational modules on the LinkedIn Learning, so you could get a little taste of her speaking and her education style.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />And then I really think this is important to put those links in your browser. So when you launch your browser to go looking for something, you see a reminder you see, oh yeah, I&#39;m taking this course, I need to go back in there. And that way, you don&#39;t forget about it. You, you trigger yourself to go and check it out and stay on task.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Absolutely. No, I love that. Well, let me take. I think that segways is well into one that&#39;s one of my favorites and, you know, the pandemic, I found myself sitting there at our state MGMA board meeting and we were discussing again postponing our conference. And at that same moment, our company had decided not to go to the MedMan National, we&#39;d also decided not to have our retreat, and I was just feeling thirsty or hungry for just developments, knowledge, to watch something, do something. And I was watching all the other ones get pulled away from me, unfortunately, but it forced me to go out and find something else and one of the things that I have loved for years is Farnam Street. They have an incredible podcast called The Knowledge Project, they have a great newsletter that comes out on Sundays, right? When I should be paying attention in church but I find myself, you know, flipping through what they&#39;re talking about way too often. But the whole organization is about better learning, better decision-making, and they had a course called decision by design, and it was all about improved decision making and learning about mental models and how to use them. And I, oh my gosh, Lauren, I love it. It is right up my alley. It is perfect for what I&#39;ve wanted to do better and to get really good at it. And so Farnam Street.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yes, I appreciate their newsletters too. I&#39;ve noticed that they come on that Sunday morning, which is really smart of them, because that&#39;s not when all the other newsletters show up.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />No, no. Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It&#39;s perfect time when you can sit there and dive into it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />They&#39;re smart. Then one of the things that I&#39;ve gotten from them is a lot of tips on becoming a better reader, and that leads me to number 16. And one of my favorites is my Goodreads app. And Goodreads is just this app that has a social side to it that I don&#39;t get into as much, but it helps me organize all of my books. Ones that I have read in the past, ones that I can scan and say, I want to read this, you know, so I have a list of want to read. It helps me keep track of what I am reading and set goals to try and you know, I want to read so many books in a year, where am I at? How what&#39;s my progress on this book kind of thing? And then finally, it&#39;ll make recommendations just like everything else in our life. You know, you read three similar books, it&#39;s going to recommend another one if you really liked it. So that&#39;s been one of the tools I&#39;ve used to try and become a more avid reader.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />That&#39;s great. Are you a real books guy ever or do you always like e-books?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love audio books. I am working on becoming a better real book kind of person. So I have a couple of books going at any given time. I have my one audio book or so I can take walks, drive around, do whatever. I have another book that I read in the morning to try and just get my head moving and I have another one at night. Normally, I don&#39;t have three going at one time. That&#39;s too much. I&#39;ve noticed that I&#39;ve really slowed down and it&#39;s hard to keep the motivation, but try and always have at least one real and one audio book going. How about you?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />That&#39;s great. I debate every time I order a book. I guess you might say I&#39;m a little bit price focused. It sort of depends if there&#39;s a deal on the e-book and it seems like a title I want to have then I will download it. But if it&#39;s something I think I might want to have as a reference later or I want stop and show people, then it&#39;s sitting on my bookshelf behind me as a real book. So it just depends.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Quite often if I read an audio book that either hits home and I need the reference, or it&#39;s one that I&#39;m going to want to lend out could, do love to. I don&#39;t know if other people love that I do this, but I show up, you&#39;re going to read this book, gosh, again.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />I loved it when you did it to me.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You&#39;re one of the few. Thank you, actually reading it. Oh man. Let&#39;s jump into our next theme, productivity, that gets us to number 17.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So one of my very favorite productivity programs, I guess you could call it GTD or getting things done. And if you haven&#39;t read the book or done the online training, I highly recommend that you do that. It is incredibly useful as far as being able to distill the many, many things that are coming at us. David Allen&#39;s turn of phrase is heads are for having ideas, not holding them, and what that means is getting out of your head onto someplace else as fast as possible, and that helps me stay organized. It&#39;s just getting it out of my head. GTD will teach you some really great techniques to do that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love it. I have actually never done the training or read the book, but I think that from previous managers who have they really beat that into me. And so it&#39;s kind of by osmosis being been able to pick up the weekly review and having notes, you know, wherever I&#39;m at, I have the ability to capture an idea and not, not pretend like I am either going to remember it or not stress my brain out trying to remember it. You&#39;ve got to be able to capture ideas right then and there, so you can let your brain move on to the having ideas, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Exactly. And what I like about it is it&#39;s not specific technology or a specific thing, it works no matter how you work. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />If you&#39;re a paper and pen person, that&#39;s completely fine. It&#39;s just a matter of organizing that paper and pen system in a way that works for you. So the crucial learning folks are also cross-trainers of the GTD system. So if you go to the crucial learning website, you can download the GTD program as well.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Perfect. I love it. The next one seems a little generic. You&#39;re going to have to help.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It is. Well, I was hoping that maybe we could come up with something together, but I wrote down apps in general. So there&#39;s a lot of different productivity apps out there. Do you have any favorites? I&#39;m opening up my phone right now.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, I use the reminders on my iPhone all the time, and that is how I kept your ideas for the GTD thing, I&#39;m always telling Siri that I need a reminder tomorrow at 10 a.m. to add it to do for calling Lauren back or something like that. I use that all the time. While you&#39;re talking, I&#39;ll think of, if I use any others.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />So one thing that came to mind is a couple of weeks ago, I read an idea about how to better arrange your apps on your phone, and I took it to heart and let me kind of describe it to you. So what it told me or what I took away from it was that your home page on your phone should really be things that are relevant and timely every day and things you want to be putting your attention on. So as an example, mine has calendar, reminders, clock, music, camera because I use my phone as my camera all the time, safari, contacts, calculator and weather. So those are the things that I pretty much look at every day. But didn&#39;t you hear in there? You didn&#39;t hear Facebook, Twitter, LinkedIn, those are on my second page, they&#39;re still there. They&#39;re still available to me. But when I pick up my phone to look at where I need to be at my next appointment, I&#39;m not distracted by, oh, look at that little app for Facebook, I&#39;m going to click on them.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />It just, it doesn&#39;t occur to me. I have to intentionally go and find all of those other things that were pulling my attention. So in addition to turning off your notifications, so that the number doesn&#39;t keep up annoying you and getting your attention, if you force yourself to go to a second page, the first week, I realized how many hundreds of times I was looking for that distraction, my brain was just looking for that and I stopped. And now it&#39;s actual intended time when I go to do that. During my lunch break or whatever, but it&#39;s not pulling me away from what I need.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So think about that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I had to take a similar step. I had to take Twitter, TikTok and YouTube just off my phone and I will if I want to redownload them Friday night and I will delete them Monday morning or something.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Oh, wow. Does that work for you?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It has to! Even if they&#39;re on another page, Lord, I, man, I love you too.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />You&#39;ll find them.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yes. And that&#39;s, that&#39;s one of the things that I realized was probably causing me a little bit of mental anguish, was that I always had to have a stimulation, to brush my teeth, I needed a one minute YouTube video, to go to the bathroom, I&#39;m going to be there, not because I&#39;m going to the bathroom, but I&#39;m hiding from my kids and I&#39;m reading Twitter, you know? And so I, just during the weekdays, I had to get drastic because I was not doing well with apps on my phone.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Oh, you&#39;re not alone, at all. They&#39;ve proven that, there&#39;s a scientific process where we get this dopamine dump when we look at these things. And that&#39;s part of the reason why I love TikTok ,is it&#39;s fun and it&#39;s funny, and it makes you laugh and YouTube videos, too. But, but you&#39;re right, it can become distracting to the point where it&#39;s making us less effective or less present in our lives or with our families. So, yeah, go ahead, move it to another page or take it off completely.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />There we go.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Whatever works. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think I can&#39;t remember who it was. It might have been Adam Grant that, oh, I can&#39;t remember who, if it was him or somebody who wrote about, but they would give the passwords to their assistant. This guy had an assistant and his assistant would change passwords Monday morning and give them back, give him his social media passwords on Friday night. And that was that was his way of blocking it, because. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />That&#39;s great.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, whether is in, I can&#39;t remember if it was, it might have been in the book Atomic Habits. I think that that&#39;s where I got that story from. Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah. If we can&#39;t trust ourselves, find someone else we can trust to help us.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />That&#39;s really smart.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Well, number 19. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah! So I like to create a lot of folders for things I need to easily find later. And I do this in my browser, I do this in my outlook, I do this everywhere, so I am super organized or I try to be, and I think folders can be your friend in so many ways. And so I just wanted to put that on there. And then also to clean it up once a year, at least get in their archives things get rid of the things you haven&#39;t needed or looked at. I just went through my shortcuts recently and my browser and realized there was a lot of stuff in there I was never going to use again, so I cleaned it all up. So make a date with yourself to reorganize every so often.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I love it. That&#39;s great. Ok, number 20. This is one that I think we&#39;re going to both have some opinions on.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Okay, so I started this process recently. I&#39;m calling it Meetless Mondays, and it&#39;s M E E T. So for me, it is a day when I walk the day for projects and I still come to the office. I still get things done, but it&#39;s dedicated chunks of time, instead of trying to carve out the chunks of time I need during the week between appointments, my job can be very varied and I can have a lot of different things coming at me at once and it&#39;s easy to get really just distracted, and not take time to really dive into those longer projects, so I wanted to put this on here as an idea that even if you can&#39;t schedule an entire meeting free day, maybe you have a meeting every morning, once a week or you have, as an organization, a policy, the company doesn&#39;t schedule meetings on Wednesdays or whatever, so that everyone has that white space, that blank space, that they need to either get things done or stop and think like you do.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, I love it. You know, that&#39;s what I&#39;m doing right now. I&#39;ve been trying to carve out a little bit of time for working on the big things and for myself. And so this kind of ties back up to number 14, the blocking time for yourself like to upskill yourself. So right now, my entire Monday is blocked to not do meetings, to spend the morning kind of working on my development skills, exercise, other stuff. And then the afternoons is for, you know, I got big rocks to move ahead. And if I&#39;m not actively trying, I&#39;m going to let the little pebbles just build up. And that&#39;s all I work on and I&#39;m never going to make any progress. So it&#39;s got to be, there&#39;s got to be some dedicated time for it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Yeah, exactly. We need that white space. We need that time that&#39;s not filled with anything else for us to just breathe too.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, absolutely. Well, I think we got to 20. I am not sure we got to twenty one. And so. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />I just thought of something, I will share this really kind of silly little tip that it will be number 21.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />OK!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />So I took an outlook class years ago and this has served me well. Many people don&#39;t know this, but when you use outlook, you can drag and drop your email into either a calendar appointments or you can drag and drop it into a task. And if you do that, you can now take it out of your inbox. It will not disappear so you can clean up your inbox just by moving the things that need action, like we talked about earlier into either an appointment request or calendar time or a task. So go through that today, drag and drop, move it into someplace else, get it out of your inbox. One of the women in healthcare events I went to, we had a little breakout session and there was a woman in the group who said out loud, where everyone could hear, that she never answered emails on the first time she waits for second or third reminders because she just has so many that she&#39;s overwhelmed and can&#39;t do it. And I thought, wow, I would never want to feel that way and would never admit that, I felt that way, so don&#39;t be that person, stay on top of your email, stay organized. And there&#39;s a little tip, drag and drop.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br /> If you&#39;re getting two hundred emails and then you let them double, of course you&#39;re gonna be overwhelmed. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Now you ....</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh no! Sounds so painful.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />These are potentially ... pools who can&#39;t get out of.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh no, I love it, I love it. That&#39;s a perfect number 21 for 2021, Lauren.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />There we go.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, thank you for sharing all of your insight and ideas. I found this to be super fun, and there&#39;s so many things I want to go out and Google as soon as we&#39;re done recording. I hope that our listeners feel the same way, but thank you for being on board.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Lauren Harris: </strong><br />Thanks, Jesse. This was so much fun. I really appreciate your friendship and the collegiality that we have as coworkers in the same industry, and I appreciate this invitation so much.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, absolutely, absolutely. And to our listeners, thank you for tuning in. I hope there&#39;s something that you get excited about and go and and look up and try and integrate into your life. Make it better in some way. Make sure that you tune in each and every week as we bring more informative episodes with some of the leaders in our industry and for anything else that MedMan does, show notes, transcripts, or other services, make sure you check us out at MedMan.com. We&#39;ll see you next week.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guest. For the show notes, transcripts, resources, and everything else MedMan does to help you level up, be sure to visit us at MedMan.com</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="automated subtitles" target="_blank" href="https://sonix.ai/features/automated-subtitles?utm_source=embed">automated subtitles</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="share transcripts" target="_blank" href="https://sonix.ai/features/share-and-publish?utm_source=embed">share transcripts</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="collaboration tools" target="_blank" href="https://sonix.ai/features/collaborate-with-teams?utm_source=embed">collaboration tools</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="transcribe multiple languages" target="_blank" href="https://sonix.ai/languages?utm_source=embed">transcribe multiple languages</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="JqYvaYbh1Qv7tedm1iZAt4Zk" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","https://sonix.ai/widget.js","https://sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->[/fusion_code] Episode Summary Welcome to the top 21 of 2021 tips, tools, and techniques episode! We are joined
Accountability
[fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">Medman Podcast_Accountability: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2021">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">Medman Podcast_Accountability: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2021">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in and we hope you enjoy today&#39;s program.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome back to the Medical Management podcast. This is Jay bringing you yet another informative episode. Today, we get to spend some more time with our very own Jesse Arnoldson discussing accountability in tough situations. Jesse, as always, it&#39;s a pleasure and welcome back! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Thanks, Jay. Hey, everybody! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So, you know, this episode is going to be about accountability, accountability in today&#39;s environment where we have so much on the line, we feel like we have so much on the line, our shoulders are heavy with the pressure of just getting through the day, a lot of that&#39;s coming from the staffing crisis and we&#39;ve talked about staffing in the past and podcast, but we haven&#39;t done so. So recently, anything change in this landscape?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. You know, in past conversations, we&#39;ve talked a lot about staff leaving, trying to figure out this whole staff, you know, quote-unquote staffing crisis. And I think that what has come from that is we&#39;ve become much more, I guess there&#39;s different motivations, but gun-shy to hold people accountable to the high standards that we normally would have. You know, we&#39;re either, we&#39;ve either always been nervous to do so, and this is just been amplified by how tough things have been lately for our teams. Maybe we haven&#39;t always handled it the best in the past, but employees haven&#39;t had another place to go. And so all of a sudden they, now that they do, they&#39;re not going to take that kind of direct or jerkish approach. Or finally, you know, we just feel bad for our teams. They&#39;ve been through a lot. They&#39;ve worked super hard. And it is really hard to hold somebody to account when you don&#39;t want to push them over the edge. You don&#39;t want to just be that last thing that breaks them. So in the end, though, that the result&#39;s the same, are, we&#39;ve lost our ability to hold people accountable and our standards are starting to, I think, weaken because of that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />That&#39;s really interesting and I completely agree with you. You know, it&#39;s interesting how we, as human beings often go into a situation or go into this situation where, you know, we&#39;re afraid that if we push a little hard, people are going to leave, but you know what I think is funny, and I&#39;ve done some just recent reflecting just kind of on my life. And I think there&#39;s at times where I felt that I didn&#39;t have enough structure or I didn&#39;t have enough boundaries, which is, you know, there&#39;s always a spectrum. And I think that that then could create this unwanted negative impact through the culture of your clinic, which is feeling like you can&#39;t push and you can&#39;t create these boundaries of accountability, you know, almost backfires in a way because now no one knows what to do or how to do it. And everyone&#39;s looking at everyone else saying, well, they don&#39;t have to do that, then what am I going to do with it? And then there&#39;s this pointing, you know, the blame game and then the spiral of like, no one knows their role in this, this little mini-society. So really, with that, what&#39;s the main issue? What are we doing? Main issue? Or what&#39;s the right path? What&#39;s the wrong path here?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, I think the main issue is that maybe we haven&#39;t in the past known how to hold people accountable very well, or it&#39;s just been complicated with recent events. But we&#39;ve got to get back to kind of the fundamental understanding of what your job is and your job isn&#39;t to be a dictator. It isn&#39;t to come out and say, hey, you&#39;re doing a terrible job or, hey, you&#39;re late again, or it isn&#39;t to be a jerk, it&#39;s to be compassionate and demanding at the same time. We&#39;re running businesses, we&#39;re trying to create highly effective teams, and you can&#39;t do that if you don&#39;t call out the bad behaviors, if you don&#39;t help people rise to the level that they&#39;re going to feel amazing about themselves for and that the rest of the team is going to feel good about them being a part of it. So I think it&#39;s back, it&#39;s less about them and it&#39;s more about us and our leadership style. You asked what the main issue is, it&#39;s our effectiveness as leaders in being able to be compassionate, be demanding, be, I guess, inspiring all at the same time. So that&#39;s it, trying to figure out what the right combination of those things are or is, are.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And what do you see as, you know, for some of our listeners here, I think might relate to what are the signs of not doing the right thing as they look in their mirror and they can say, well, how do I know I&#39;m on the right path or the wrong path, really? What are those wrong path symptoms that they should be looking out for? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />A couple of them. One is if I push this person, they&#39;re just going to quit. I can&#39;t do it, I can&#39;t lose another person. We&#39;ve just been, It feels like a war zone here. We just keep losing people and I can&#39;t do anything that&#39;s going to risk another one going. That&#39;s a bad place to be. And you&#39;re now held hostage to whatever these people want to do because you aren&#39;t willing or aren&#39;t, you don&#39;t believe you&#39;re able to. That&#39;s that&#39;s a symptom right there. A red flag symptom. Another one would be on the completely other side of the spectrum, I don&#39;t have time for this. I just don&#39;t have time for these people and their weird emotions, like back in my day, you just took pride in your work and you just got the job done. I&#39;ve always called BS on that and even more so now, like, that&#39;s a symptom that you&#39;re not in the right mindset. You&#39;re in the people business. As a manager and as a leader, you do have time, that is your primary job is to address these people as, as human beings and use the human approach to help them get back where they need to be. So I&#39;d say those are two biggest signs you&#39;re on the wrong path. What do you think about that?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I&#39;m with you. I think that you get stuck a lot in those two places mostly, and just reflecting back, I think sometimes we correlate the wrong action to the result. And I think oftentimes could very well be because we&#39;re lacking in structure and accountability is creating some of this turnover, right? So it&#39;s almost like what really is causing it? Well, it&#39;s, maybe this is being caused, your prior turnover is because it&#39;s like prevent defense, right, with the only thing that we know about prevent defense is that touchdowns will be scored. And so which is ironic because, you know, most of the time you&#39;re like, God, geez, what are they going down this path? And I think it&#39;s the same thing. Like when we come in defense mode, which we stop doing the things that ultimately made us strong and made us successful. And I think that&#39;s what we&#39;re getting. And I think those are two great examples of us going into defense mode, acting as if differently than what we would have done, what we did do to create a strong culture and a strong team. All of a sudden we&#39;re breaking all that down and then it&#39;s a snowball effect of, you know, little by little, it builds up steam, not because of, you know, the actual circumstances is, because how we&#39;re interacting with the circumstances is making it worse and worse and worse.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And think about it, if you&#39;re not going to hold somebody accountable because you&#39;re in that first bucket of, of being scared of losing more people, I think that you&#39;re putting little pebbles on the scale for other people to probably exit because they&#39;re going to get frustrated because they&#39;re still working hard. And Jesse is letting so-and-so skate on X, Y or Z, you know, you are adding one way or the other to the certainty that somebody is going to leave. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And the wrong somebody, right? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And that ultimately, what? What happens? Absolutely. I&#39;m with you. So then let&#39;s share your wisdom, Jesse, on what are we going to do? You know, how do we go about that? Are there? Is it just revert back to what you used to do or what are some steps then you can take to try to hold our people more accountable?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think that more and more where we&#39;re getting pushed to is not a bad place. I talked about the kind of person that is like, yeah, back in the day, I just, you know, we came to work, we did our job and that&#39;s how things were back in the good old days. I think that we&#39;re being pushed more and more to recognize people as real human beings in our business, and this is just one more big, gigantic push to get there. As we&#39;re approaching people, people want to do well, they want to be good at their jobs, they want to take care of their team. We just have, you know, sides to us that aren&#39;t as strong as our ideals. And sometimes you just need to be coached in that. I&#39;m not saying everybody, you know, some people are just, they need to go or they need to be reprimanded for whatever, you know, because they&#39;re just not in it. But most people desire a good guidance, good leadership. And so I think that where we have to go from here is just taking individual human approaches, being honest and open with them in conversations, hey, this is going on, I got to get you to a better place, what are we going to do about it? Help me get you there. You know, I think that most people respect that, and I think that that&#39;s where most people need us to be. It has been a really hard couple of years, and I&#39;ll be honest, if somebody just comes and lays the hammer on me, I&#39;m going to react poorly. But if somebody comes to me and puts their arm around me and says, Jesse, hey, this, I know you&#39;re working super hard, I know where you&#39;re at, this thing is not where it needs to be, and I want to help you get to a better place. I can get there, even if I&#39;m in a hard, hard mindset, even if I&#39;m stressed and a little burned out. I think that that&#39;s where we have to be. I feel like that&#39;s what&#39;s naturally evolving in our industry.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I agree with you. I think that this whole pandemic has shown light on areas that needed vast improvement. And I think not just in health care, but all other, a lot of sectors. We&#39;re realizing that the people that do a lot of the work can actually exchange mostly with customers, patients, all that, aren&#39;t treated well, aren&#39;t paid well, aren&#39;t in environments that ultimately are fulfilling. And so it&#39;s really, we get to deal with that today for a better tomorrow. I ultimately think a lot better tomorrow. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think so too.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I&#39;ll go back to just one thing to add, which is consistency. And I think for the second bucket that we mentioned of why I just don&#39;t have time, I think it&#39;s really important then to reflect and say, well, let&#39;s not allow the I don&#39;t have time to be, you know, the stop for me doing anything. But I think then what you&#39;re going to have to really reflect on is then what can I do consistently to the team as far as setting accountability and expectations? So it&#39;s not I&#39;m doing this once on here or there. You really just reflect and say, OK, prioritize those things and then be consistent about pushing them forward for the whole team. And I think that&#39;s going to make it a lot easier and certainly give a little bit more buy-in, it doesn&#39;t have to be you come in with like 15 different expectations, accountability for everything. It&#39;s just pick one or two and start building on that and then be consistent.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />So I mean, I guess it comes down to three things, right? Have the courage to actually step in and intervene when you&#39;re supposed to, be the leader that you need to be, be consistent and just take a human approach to it. I&#39;d say those are the three things to do to get past this whole accountability roadblock that we got going on.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And I just, you know, here&#39;s a moment to praise Jesse a little bit and see his grin widen. Jesse, just you have an amazing approach to relationships and people that I think oftentimes gets brushed underneath the rug just because there&#39;s this pressure of getting everything else done. And I think we all just need to absorb your intention of people first, be there, be the human next to another human and treat them as such and things are going to work out. And I think oftentimes we&#39;re just like, well, we got to get all this stuff done and we&#39;re more in robot mode than human being mode. And so I do appreciate you continually reminding us that we&#39;re in the people business. We&#39;re human beings, so let&#39;s act like it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I appreciate that, Jay. It just, my skill isn&#39;t very good, and I&#39;m OK with that. It&#39;s getting better. But my intent is there like, I want to take care of the people around me. And that&#39;s, I think that when people know that that&#39;s truly your intent, they give you a lot of grace when maybe you don&#39;t say the right things, or maybe you&#39;re a little too harsh on this or whatever it may be, as long as they know your intent, they work harder, they want to do better. They give a lot more grace to you and those around you. So I appreciate that, Jay, that&#39;s definitely something I try and work hard on.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Well, it shows and big time and very important, I think for struggling, I think you fall back to that, which I think a lot of this is, is treat people how you want to be treated and approach it in a humane way. And you know, ultimately, it&#39;s not the fact that this whole thing is to make people feel worse, it&#39;s to give them the right structure to work within. And we all need that. And there&#39;s a right way and a wrong way to do it. So thank you, Jesse, for sharing your insight here on helping us keep accountability going, keeping this culture, the boundaries and helping us move past this, because pretty soon we&#39;re going to be thinking about a pandemic as something that happened in the past. But all this stuff isn&#39;t going to change. We&#39;re still going to have all these people issues. It&#39;s a great place to end. Appreciate you, Jesse, and I&#39;m sure all of our listeners out there gained a ton.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Thanks, Jay. Thank you, everybody. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />For all you listening, thank you for tuning in today. I really hope you enjoyed our conversation with Jesse. As always, show notes, transcripts, material from the show and really everything else MedMan does, you can find on our website, MedMan.com. We&#39;re going to be here every week sharing insights, ideas and tools to help you level up your practice. Thanks again for joining us.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guest. For the show notes, transcripts, resources, and everything else, MedMan does to help you level up, be sure to visit us at MedMan.com</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="world-class support" target="_blank" href="https://sonix.ai/features/world-class-support?utm_source=embed">world-class support</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="share transcripts" target="_blank" href="https://sonix.ai/features/share-and-publish?utm_source=embed">share transcripts</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="enterprise-grade admin tools" target="_blank" href="https://sonix.ai/features/admin-tools?utm_source=embed">enterprise-grade admin tools</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="transcribe multiple languages" target="_blank" href="https://sonix.ai/languages?utm_source=embed">transcribe multiple languages</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="myGPZwEZ4EoY6NNJiRghYKsr" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","//sonix.ai/widget.js","//sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->

[/fusion_code] Episode Summary Today’s episode is about accountability in tough situations. Holding someone accountable to the high standards
The Terrible Act of Firing Someone
[fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">The Medical Management Podcast_The Terrible Act of Firing Someone: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2021">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">The Medical Management Podcast_The Terrible Act of Firing Someone: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2021">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in and we hope you enjoy today&#39;s program.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome back to the Medical Management Podcast, this is Jay, bringing you another informative episode. Today, we&#39;re going to spend some time with our very own Jesse Arnoldson discussing the terrible act of letting someone go. What a fun topic, right? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right! </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Everyone&#39;s most favorite thing to do.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Let&#39;s get uncomfortable!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />You know, that&#39;s got to be one of my mottos in life, that I just need to formalize here, let&#39;s get uncomfortable. Then we&#39;re knowing we&#39;re making some progress.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, yeah, exactly.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So let&#39;s just touch on a really hard subject which is letting someone go. Talk to me about that, Jesse. Just overall, how about this? Let&#39;s start off with overall, how do you feel just when we bring that up? </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Man, I get sick to my stomach, I hate it. You know, these are real people, and most of the time, Jay, I don&#39;t think I&#39;ve, I think I&#39;ve ever let anybody go that wasn&#39;t a nice, kind human being. You know, I&#39;ve never had the chance to just tell the worst jerk ever to just shove off, they&#39;re fired. You know, it&#39;s, it never is that. And so it makes it really, really hard. And the first time I ever had to do it, our old CEO and owner of MedMan, Jim Trounson, you know, was talking to me and I was just telling them how I didn&#39;t sleep the night before I had to do it, I had to fire this person. I had a hard time eating. I just felt so uncomfortable and sick to my stomach. And I asked, I was like, you know, does it get easier? You know, do you just get better at it? Is it always like this? And he looked at me, and this is a point where he&#39;s seventy-one years old, 40, you know, 50 years into his career. And he&#39;s like, you know, Jesse, it doesn&#39;t. It doesn&#39;t get better. It doesn&#39;t get easier. And if it does, that&#39;s a red flag for you to change your careers because you&#39;re probably turning into something you didn&#39;t want to be in the first place. So that&#39;s, that was his advice.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Well, that being said, you know, what can we do to become better at it, right? I mean, with our confidence, if our confidence goes up, ultimately, if we can feel better about the process, we can maybe sleep better at night, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />If we can treat people like human beings and we can do that because we have a good process, then at least we can keep that relationship going.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Tell us some of those mistakes that we make.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, of course. Of course. I, let me build just really quick on what you&#39;re saying. If you can separate being better at the process versus, you know, not feeling the uncomfortable emotions that come with it, those are two separate things, and that&#39;s what I&#39;ve learned. I kind of had them tied together in the beginning, and since then I&#39;ve separated the two, and that&#39;s probably one of the first pitfalls is thinking the two are combined, and, you know, entirely and you can&#39;t separate the two. I don&#39;t think you should ever get comfortable with firing somebody, like Jim was alluding to that, that&#39;s a place I don&#39;t want to be, I don&#39;t want to be that monster. But do I have my ducks in a row? Am I doing it for the right reasons? Have I done everything I can? Am I doing it in a way that is just like you said, am I treating them like a human being? If I can do all of that, that&#39;s the kind of skills that we need to develop and why we&#39;re talking about it on the podcast? This isn&#39;t to make you feel better, necessarily, it&#39;s to make you, help you in your skill management to mitigate risk, to make it a better and humane process, and to help the organization. That&#39;s it. But to your question, Jay, you know a long-winded answer here, you&#39;re asking about pitfalls, right? Like, why are we gun-shy?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, both sides, right? How do we become better? So there&#39;s mistakes or what things are like, you know what? You&#39;ve got to knock this out of the park.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />What should we be looking for?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Well, let&#39;s start with mistakes. Those are the easiest things to point out. First things first, you know, you&#39;ve held on to somebody for too long. What&#39;s the phrase? Hire slow, fire fast. You know, it couldn&#39;t be a, I subscribe to that. I think it&#39;s a true statement because again, combining those two things of letting somebody go versus how we feel, we need to separate those and for the better and betterment of the organization and the people inside it, sometimes people need to leave, and that&#39;s OK. Sometimes we don&#39;t want the turnover because it makes us, it&#39;s almost like a badge of failure if we&#39;re having two or three people out of the organization. Also, we&#39;re experiencing high turnover and everybody&#39;s wondering what&#39;s going on. You know, that we freak out pretty bad more than probably anybody else thinking about that. But really, the mistake we&#39;re making there is hanging on to somebody who is making the organization worse or holding them back. If I&#39;m slow to fire somebody who is not living up to our values, then I&#39;m showing people in the organization that our values don&#39;t matter as much. If I&#39;m holding on to somebody who just can&#39;t do the job, then I&#39;m probably putting more work on their teammates and they&#39;re going to struggle with that. There&#39;s lots of different versions of that, but hanging on to somebody for too long is the first one. Other mistakes, other major pitfalls, not being fully prepared to do so. You know, I think probably one of the most common things is that people have not had the discussion with the person and painted the realistic picture in front of them. That&#39;s what I&#39;m talking about with not being ready to fire. You haven&#39;t given them the real picture. You&#39;ve either not talked to them or given them too rosy of a picture. You&#39;ve cherry coated it. And then second, you haven&#39;t documented, you have not documented properly to let somebody go. And that&#39;s my most common one because I hate documenting, I hate policies, if I have a conversation with somebody, to like, Hey, Jay, you know, you really, you got to watch your mouth at the front desk. You know, that cussing is going to get you in trouble. And then I&#39;m like, yeah, yeah, in my mind, yeah, Jay gets it. We had that conversation, he&#39;s not going to do it again. And so I don&#39;t document it. Well, guess what, when Jay drops an F-word next week and I&#39;m having to backtrack and document again and or whatever, you know, that&#39;s, that&#39;s a problem.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Just say it never happened.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Just say it never happened, what are you talking about?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />No. Me, dropping that bomb?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. Yeah, yeah, that&#39;s never happened. But those are probably the most common. We fire too slow, we cherry coat the picture for people so that they don&#39;t have a realistic idea of what&#39;s going on until it&#39;s firing time. And three, we&#39;re not documenting properly. Those are probably the three most common mistakes.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, absolutely. They kind of build on each other, right? You know, give that person a runway, be honest with expectations, and then, you know, because our memories, I don&#39;t think our memories are really on our team, most of the time, for whatever reason.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />But yeah, that&#39;s what you have to have documentation like, no, this is what, and oftentimes it&#39;s good to do that together to say, look, we&#39;re writing it down because in a month, I don&#39;t want to come back and say, well, this is what I thought I said, like. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Isn&#39;t this what we said? Yeah, let&#39;s, now we can go back and use this to grow from and certainly helps then changes the conversation of, I&#39;m letting you go because I don&#39;t like you to you&#39;re not a good fit because you, we just haven&#39;t, you haven&#39;t gotten to where we need to, you need to be. And it&#39;s a, at the end of the day, it&#39;s not like it&#39;s going to be a fun situation.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />No. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />We have emotions, we&#39;re going to feel bad. But at least there&#39;s logic to it. At least there can go, well, yeah, I went to A, B and C, but I never, never broke through that and really progressed. At least there&#39;s something there.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly. I think that probably a good way to look at this, Jay, is to look at those mistakes and flip them over. So, so if you&#39;re you&#39;re holding on to somebody too long, you know? No. Be courageous to address things head-on. Be timely about it. If you&#39;re not preparing the people, you know, you need to be direct. Not a jerk. Kindly and compassionately sharing real feedback. And then finally, you know, making sure that that documentation is there just making notes. Probably one of the best pieces of advice I ever got when I was in the clinic was to just have a word document where whenever I did a one-on-one or had a heavy conversation, I just kept a little two-sentence diary on every conversation I had, with dates, and that was it. You know, that was my method. I think a fourth mistake is that when it comes time for the actual act of letting them go, in the past I have been too open, like I just kind of go on and on and I&#39;m too loose with my lips. And that&#39;s when we get into the topic of risk management, Jay, it&#39;s when it comes time to actually let somebody go, again, kindly and compassionately, but you don&#39;t need to spill your guts on everything, every reason, every pla-da-da, negotiating, and kind of going back and forth is not humane. It&#39;s not kind and it&#39;s risky. So understanding what you&#39;re going to say and being quick and deliberate is probably my way of describing it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And that&#39;s really, you know, talking about the things that you think you need to be prepared with when it finally comes time, elaborate on that a little bit. We&#39;ve got, you know, making sure you know why you&#39;re going to do it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Making sure you don&#39;t talk outside that scope. Anything else that you can help someone prepare for that moment?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />One of the best things, one of the things at MedMan that I have taken full advantage of is we have a retainer with a legal firm here in Boise, and I always reach out to them. I reach out to them, I reach out to HR resources, I try and put all my cards out there of what&#39;s going on and have somebody else double-check me. And I&#39;ve yet to regret doing that. 9 times out of 10, 10 times out of 10, they&#39;ve pointed out something I&#39;ve missed or what I should have done, or they give me good advice on how to mitigate my risk. Sometimes, you know, severance, payout, with a release of liability, a release of claims, or a release of liability agreement is an amazing path. And I wouldn&#39;t know that unless I had gone to my attorney and talked it through. Documentation, making sure we have proper documentation, they can review that. Getting that expert pair of eyes and ears on the situation to just double-check, is probably the best thing that you could do in your deliberation.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, and unfortunately, as times get harder and harder, the risk grows.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So really making sure that you&#39;re not opening up an opportunity for someone to come back and say things you didn&#39;t say and ultimately put you and the organization and in a really bad spot?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh, you mentioned something, Jay, he said, kind of, he-said-she-said situation, I don&#39;t think I&#39;ve ever let anybody go by myself. And so either I have one of our physicians there or another manager or I&#39;ve had it where our HR resource sent somebody to just come in and sit with me, not because I&#39;m chicken and I can&#39;t do it by myself, but I am not going to be caught in a situation where it&#39;s just word against word.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />That&#39;s a great point. How do you stumble on that? Was that from a recommendation or was that just trial and error?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think it was initially an accident. Like, I just, my first couple I didn&#39;t want to do by myself until somebody else was there. And then when it came time again to reach out to our HR resource and our legal resource, they&#39;re like, OK, this one&#39;s a risky one. You know, you&#39;ve said that this person is pretty dicey and it&#39;s confrontational and has been, you know, in a lot of conflicts with other employees. You really need to have somebody there, who are you going to have? And so we figure that out and that for me from then on was just a best practice.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I like it. There&#39;s a ton. There&#39;s a ton of benefit, you know, after you get past that person&#39;s going to walk into a room, two people are looking at them like, you know, what&#39;s going down? And then, you know, oh. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Getting over that barrier. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, well, that&#39;s you know, you bring up probably the last piece of advice I&#39;ll give on this unless you have other questions, but, people know what&#39;s happening. I mean, probably one of the worst things you can do after you&#39;ve let somebody go is not be on and open and honest with your team. I&#39;m not going to go in there and give all the reasons I fired so-and-so, but I&#39;m going to go talk to them and say, hey, I just let so-and-so go. And I think it&#39;s best for the organization and it&#39;s really painful. I want you to know that. And then lastly, you know, like I just said, I&#39;m not going to go into detail about it, I&#39;m also not going to bash that person, and I don&#39;t ever want to hear you bash them either. We&#39;re going to respect them and, you know, people make mistakes and we move on, but we respect each other. And that move is not, I don&#39;t use it as a tactic. I really mean those things when I say it, but it is probably one of the most impactful things for those that stay because you have to think about the people who remain after somebody&#39;s been fired and how to best treat them. Because on the flip side, what can happen from there? They can feel paranoid, they can feel stressed, their trust can be eroded immediately, you know, not eroded, but destroyed in a moment if this is done incorrectly. So that&#39;s probably the most important thing after you&#39;ve thought about all the legal and how we&#39;re going to do it. And yes, let&#39;s do it. Now, let&#39;s think about the people who are left behind and how to build trust and integrity on the other side of this.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Hey, man, I think that&#39;s a great place to end, and I&#39;ll double down on that because it could very well be them the next time, and how insecure would you be if all of a sudden your organization celebrated you leaving. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />You have to lead, you have to have integrity. So that&#39;s a great point and a good, really good place to end. You talked about being open and honest. We really appreciate you, Jesse, being open and honest about a really difficult subject here. So thanks for hanging out and talking to us about the best way to let someone go.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Thanks, Jay, thanks, everybody!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Everyone that&#39;s tuning in. I hope you enjoyed our conversation with Jesse. For the show notes, transcripts, material from the show, and you know what everything else MedMan does, head over to our website at MedMan.com. Remember, we&#39;ll be here every week, sharing insights, ideas, and tools to help you level up your practice. Thanks again for tuning in today. We&#39;ll catch you next time.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guest. For the show notes, transcripts, resources, and everything else MedMan does to help you level up be sure to visit us at MedMan.com</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="secure transcription and file storage" target="_blank" href="https://sonix.ai/features/security?utm_source=embed">secure transcription and file storage</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="transcribe multiple languages" target="_blank" href="https://sonix.ai/languages?utm_source=embed">transcribe multiple languages</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="share transcripts" target="_blank" href="https://sonix.ai/features/share-and-publish?utm_source=embed">share transcripts</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="collaboration tools" target="_blank" href="https://sonix.ai/features/collaborate-with-teams?utm_source=embed">collaboration tools</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="Q4wQUfTbpg8JAJb5PZg5K7QC" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","//sonix.ai/widget.js","//sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->

[/fusion_code] Episode Summary This week’s episode is about the terrible act of letting someone go. Both employer and
Building Trust in Teams Jesse and Jay
[fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">The Medical Management Podcast_Building Trust in Teams: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2021">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">The Medical Management Podcast_Building Trust in Teams: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2021">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in and we hope you enjoy today&#39;s program. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome back to the Medical Management Podcast. This is Jay bringing you another informative episode. Today, we get to spend more time with our very own Jesse Arnoldson. And, you know, he&#39;s going to discuss how trust is the foundational part to most team problems. And Jesse, these are my favorite, favorite days. We get to hang out and talk, and welcome.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Mine too, buddy.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So, you know, let&#39;s think about this here, whenever we go into clinics that are having significant issues, it&#39;s always the Pareto Principle, right, the 80-20 rule, where 80% of their problems are people problems. We like to say that a lot and we don&#39;t just like it because it&#39;s fun, we like it because it&#39;s true. Bottom line. And so what&#39;s the common thread here?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You know, whenever we go into these clinics, Jay, they always have an assumption of what they think their problems are. And sometimes they see that they have people problems, but a lot, but most of the time they think that they have compliance or workflows or financial problems. And maybe they do to a certain extent, but they&#39;re caused mostly by the people problems that they have in their clinic. And quite often you can peel the onion back and at its core is a problem of trust, you know, and we can reference the management guru of Patrick Lencioni, and The Five Dysfunctions of a Team, but at the bottom of his pyramid is the first dysfunction, and that&#39;s a lack of trust. And so, you know, I don&#39;t think that you and I are, are preaching anything too off base. Multiple experts agree on the same thing, whether it&#39;s that you&#39;re bad at conflict or you&#39;re not getting results or you&#39;re, you feel like maybe your, your people aren&#39;t a good fit, whatever it may be, you can usually peel it back and find that it&#39;s a problem having to do with trust amongst your people.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I couldn&#39;t agree more, you know, just being vulnerable is an outcome of trust. And, you know, if you trust your environment, you trust your people, then you&#39;re allowed, you&#39;re allowing yourself to be vulnerable. You know, I think being vulnerable is one of my most feared and favorite experiences and feelings ever, because, you know, if you&#39;re not vulnerable, then you&#39;re really not a learner, and that&#39;s kind of the motto that I go with. And so trust is key to that and it&#39;s key to growth. And so as a practice manager, you can decide that you can decrease the trust of your organization and increase all the work you have to do. Or you can increase the trust with your team and really decrease the work you have to do because everyone else is going to pitch in, you know, and that&#39;s the tradeoff.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And that&#39;s the thing, you know, a few, I&#39;ve been listening to a few people talk about trust or the lack of it as a tax. If you live a life in which you withhold trust or it&#39;s very difficult to gain your confidence, you&#39;re going to pay a tax for that. You&#39;re going to do more work. You&#39;re going to have to buy more of your own tools. And what I mean by that is in your community, if you don&#39;t have a relationship with anybody and don&#39;t trust anybody, what&#39;s been found is that you will most likely have to buy all the tools that you would use one time rather than being able to go to a friend or a neighbor, a family member and borrow. And so it&#39;s this tax on your time, your money, that only occurs because of your ability or lack of ability to trust people. And so I think quite often Jay, you know, there&#39;s multiple problems when you come at the topic of trust. One of the most common is that people have different ideas of what trust means. And so some people feel like it&#39;s something that has to be hard-earned, like you and I need to spend the next five years together and you need to come through on a whole bunch of stuff before I ever put an ounce of confidence in you. And that&#39;s expensive. That&#39;s you know, if you live that life, you&#39;re going to be paying that tax that these folks we&#39;re talking about at a very high rate. But a lot of times people don&#39;t see trust that same way. There&#39;s different definitions, different expectations, and that is probably what leads to most confrontations around this topic.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Absolutely. I love the analogy of borrowing tools or needing things, because, you know, I&#39;ve gone through that in a neighbor, just recently bought a ladder that is strikingly similar to the ladder I have. And I&#39;ll tell you what, I probably use this ladder maybe once a month. So there are bountiful opportunities to borrow the ladder. And I looked at her and I&#39;m like, what are you doing? Like, what, what about our relationship don&#39;t you feel comfortable with just saying, hey, Jay, can I borrow your ladder? You know, you kind of scratch your head and say, yeah, well, what&#39;s going on? But I love that because it&#39;s so true.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Think about, Jay, in MedMan we enforce a community that shares its tools, right, it states its expertise. That ladder, I don&#39;t need to go out and teach myself exactly how to go do X, Y, Z in this EHR, I don&#39;t necessarily have to go buy my own ladder, I can call somebody and ask and get the help, but that only comes from a trusting relationship. Otherwise, you know, like I said, you&#39;re paying that tax. I&#39;m going to spend the next two hours figuring out how to do this specific problem because I don&#39;t have anybody in my life to reach out to and I don&#39;t have the trust built to do so.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Totally. Absolutely. And, you know, we&#39;re always talking about building trust, but it seems like we abuse and overuse the term to the point where maybe it&#39;s become a buzzword. How do we actually develop genuine trust in one another?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah, you know, I think it starts with getting on the same page about what trust means to each other. You know, if you and I are the ones having problems, Jay, sometimes it can pay dividends down the road in the conversation. If you and I are just, same page about what that means. From a lot of people trust is, they kind of pervert the idea of what trust is. They think, you know, this person is asking about how my project is going. They don&#39;t think I&#39;ve got this. They don&#39;t trust that I know what I&#39;m doing. They keep inserting their own ideas and I don&#39;t like that. They don&#39;t, I&#39;m the one that, you know, knows what I&#39;m doing, they don&#39;t trust that. That&#39;s, that is, in every sense of the word, a perversion of what trust is, truly is. And so a lot of times you&#39;re having to pull people back from what a false sense of trust is. And you can&#39;t move on. You can&#39;t have a different conversation or a better conversation around trust and confidence in one another until you fix that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Well, it&#39;s not maybe a false sense of what trust is. It&#39;s a false sense of the questioning of, right, the lack of trust. I mean, that&#39;s probably more of it where all these, these cues are picked up, as, you know, someone doesn&#39;t trust me, the insecurity part of it. And it&#39;s not that why I don&#39;t get trusted, it&#39;s these actions are weakening my trust when it&#39;s completely not, right? You get in this game where I don&#39;t want to be helpful. And that&#39;s the beauty of life, right, 99% of the time intentions are right, actions are wrong or actions are interpreted as wrong, and I think this is certainly, you know, circumstance. So keep going.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Well, it&#39;s interesting. If this was a simple problem to solve, there&#39;d be a simple solution. These are complex issues around people and emotions. And so, think about what goes into this interaction. Somebody might be insecure, somebody might be new to the relationship, somebody might just be trying to hold somebody accountable, right, like they might just be trying to do their job of holding somebody, of oversight, right? Let&#39;s take, for example, I saw a scenario play-out in a clinic not too long ago where a new manager came in and had one of their mid-level managers working on something, working on kind of the roles within their department. And that mid-level manager, that lead, just took off and started making changes. And this new manager kind of inserted herself and started asking questions and wanting to get to know it. And that came across as quite offensive, why? One, because I think that the lead was a little bit insecure in her role, already, and that had nothing to do with the new manager, and then this new manager needed to just get in the know, insert herself, apply her own ideas, be involved, not necessarily to be the one to make the decisions or, or to micromanage it, but to get involved and that came across as a lack of trust because they hadn&#39;t built anything yet. And so the same actions that maybe could be taken by a manager who had been there a little while and had built relationships and built trust and had kind of some common practices, could have done it the exact same way and had it come across differently. And so all of these problems have multiple layers to them, is what I&#39;m trying to get to.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, it&#39;s so, I mean. It&#39;s so funny, I mean, it&#39;s funny, but it&#39;s not because, you know, you have this manager who&#39;s trying to build trust by saying, I want to be involved, but in doing so, I care, I want to be involved, I want to have you feel like, you know, I care about you and I&#39;m going to interact with you. And in doing so, creates the exact opposite environment that they want, which is like</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And then they can&#39;t figure out why, it&#39;s stuck because, you know, what, what did I do that was so wrong? I just, I just started to have a conversation about this.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Absolutely. Yeah, yeah. People, people are amazing, amazing creatures. Let&#39;s just say that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And so, Jay, back to the original question. You asked me, you know, it&#39;s, it&#39;s become a buzzword. How do we actually develop authentic trust, right, or genuine trust? I think step one, which I gave way too long of an answer for, was, get on the same page about what trust means and what it means in relation to accountability, in relation to how you&#39;re going to do your work, the confidence you already have in this person. So same page there, same page in there is absolutely essential before moving on. I think after that, it&#39;s realizing that building trust requires you to do extra work. It requires you to spend extra time with this person that you&#39;re trying to develop confidence in or between, and it requires more opportunities that back to actually develop trust. You aren&#39;t going to build it by simply, you know, engaging in small talk or going out after work for drinks. Those things are fine. Company parties are fine. Those are moments where you can socialize and stuff, but trust is developed through working together to solve problems, getting through hard trials, doing hard things, accomplishing stuff together, having difficult conversations, giving feedback, and receiving it back and forth, those things require opportunities and you have to have a lot of them to practice and to build up. And so, you know, as I&#39;ve realized, I&#39;ve had to, if I really need to build trust in somebody, I&#39;ve got to go out of my way to create an opportunity for that person to do what I, you know, to, to do it right. And that doesn&#39;t happen, if you withhold those or you just go about your normal day, you have to be looking for ways to extend an opportunity to build that relationship, that trust.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, right, but to the story you told, one of the best ways in my mind and in my experience to build trust is to, to extend that space for that person to work in. And, and, you know, just, you think about how and just relate it to kids, you know, you can certainly tell your kids what to do and how to do it all the time, because, you know, inevitably they&#39;re not going to do something right, most of the time, you know, because they&#39;re learning things and you know what I&#39;m talking, you know, just, they&#39;re always learning. And the fastest way to decrease that trust is that no matter what they do, you&#39;re always inserting, well you can do it this way, you should&#39;ve done that, you should fix that. And I think that goes to how we build trust in teams and say, hey, here&#39;s a directive or here&#39;s a goal and you have the, you know, the autonomy to do it, how you see fit, and then afterwards, I&#39;m going to, then, question how you felt that outcome was, rather than immediately saying, well, in my opinion, you could have done it better and these are the ten reasons you could have done it better. That, that ultimately as a human being is very hard to process because usually, we lead with these are the things that you could have done better rather than let&#39;s look at both sides and really build from there. And there&#39;s just been, there&#39;s been studies done to show that every time you try to add your own ideas, or your idea of an improvement, or whatever to a situation or a project, it reduces the motivation and the passion that the original person had, and you actually get a worse outcome, even though you&#39;ve had tried and trued, you know, you&#39;ve already tripped on that rock and you&#39;re saying don&#39;t trip on that rock. Oftentimes because of our psychology we, we then take that as you don&#39;t trust me, then it turns into I&#39;m not as motivated and you don&#39;t work as hard and you actually get a worse outcome for pointing out the things, if you do that. But if you can build that relationship with, hey, when you get stuck, come to me.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And I&#39;m going to help you through it. But I&#39;m not going to lead and say I don&#39;t think, I know that you&#39;re going to trip on that rock, so I&#39;m going to tell you about it. That&#39;s just, it&#39;s hard for a human being to take that. And so it&#39;s really having the patience and having the reserve to say, I&#39;m here for you and I hope that when you get stuck, you can come to me and then sitting around. And believe it or not, how, how you mentioned, we think trust is built by a lot of little interactions, but it&#39;s almost, it&#39;s really built by allowing less interactions but more guided from the other party coming to you. So it&#39;s not you saying, hey, you know, every day, let me say hi, hi, hi, it&#39;s really saying, hey, you do your own thing, you wander around and when you get lost or you get stuck, then come to me. And that actually is the thing that builds the trust, not, you know, I&#39;m going to come by and say hi to you at your desk and we&#39;re going to feel, you know, warm and fuzzy and, and pretty soon we&#39;re going to be the best of friends and trust each other. That&#39;s not how it does, it&#39;s not how it works.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You know, I think in some instances, for our listeners that are looking for a specific, you know, two or three things that they can do to try and help develop trust within their team, I think one of them is exactly what you&#39;re talking about. You know, let loose on the reins a little bit, don&#39;t offer that last 5%, like if somebody shows you what they&#39;re doing and there&#39;s, you could make a 1 to 5% critique, don&#39;t, just let it simmer, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Totally, yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Let people have their space to work, that will help. Two, setting very defined expectations of what accountability looks like. Hey, I really want, you know, I have this project in mind for you, here&#39;s a space to work within, here are the parameters to do whatever you want. I&#39;m going, but I am going to check in and I don&#39;t want you to take that as that I&#39;m micromanaging or I don&#39;t trust you, but this is what a healthy accountability looks like. I&#39;m going to check in and I&#39;m going to ask questions, I&#39;m going to offer up ideas, but really this is your thing. And then, you know, another version of it is I like to build trust through problem-solving. I like to go to somebody and ask for advice. And when people do that, because I&#39;ve, I&#39;ve had people do that with me, you know, you&#39;ve done that Jay, in instances where my opinion isn&#39;t necessarily needed, but sought and that one does help my ego a little bit when that happens, I admit to that, but to it, it makes me feel like a trusted confidant. And so if I can turn around and offer that to somebody and say, hey, I&#39;m dealing with this issue, I think I know what I want to do, but I&#39;d really like to get your insight because I like the way you think and I want to see different viewpoints on it before I make a decision. And walking through that and asking questions, being careful not to jump and start debating whether, you know, whether what they&#39;re saying is right or not. But those are the types of things that you can do. They&#39;re not huge. They don&#39;t require you to take time out of your, you know, shut the clinic down and go do trust falls somewhere, but these are real interactions with your team that can build trust. And probably the last one, Jay, if you&#39;re in touch with your team, you&#39;re going to figure out that 75% of them are going through something in their lives. And I don&#39;t think that we should become counselor, but being able to have a finger on the pulse of how our folks are doing and being there for them, that is absolutely a wonderful opportunity to build trust. And it has to be sincere, you have to be coming from the right place. If they get the sense that you&#39;re doing this to manipulate them and try and, you know, build trust with them because their grandpa died, like that is going to backfire. So you really do need to come from a place of genuine concern for your, your folks.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, absolutely, and, and I understand, you know, we&#39;re all people and there are influences outside of what we see that impact us and if you decide to exclude that, then, you know, it just makes it harder for all of us. Let&#39;s end this right here with a, you know, let&#39;s say that we kind of know that it&#39;s important, but let&#39;s just dive into why, you know, what do you see here as the biggest benefit? What&#39;s the power that comes from, from building trust with your team?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You know, it allows for so many of the other right things to happen. If somebody trusts that they can come to me and disagree, if they can come and argue with me and they know I&#39;m not going to, that I&#39;m going to, you know, respect what they&#39;re saying, I&#39;m going to ask questions, I&#39;m going to engage with them, and very well might change my mind but even if I don&#39;t, you know, I show those other things, I&#39;m going to get the best out of my group. If they feel they can be vulnerable, then they&#39;re going to work, you know, without fear and anxiety. If they&#39;re not worried about making, that mistakes are going to sink them, then they&#39;re going to try harder, they&#39;re going to implement new ideas, they&#39;re going to bring new ideas to the table. I just imagine a workplace, a team in which that fear and anxiety of failing or retribution or getting my ideas knocked down doesn&#39;t exist. And what can you do if you have so much more of your mental capacity returned to you because you&#39;re not worrying about those things? What more can you do? It&#39;s, I feel like the sky is the limit because most of us probably have twenty or thirty or even more percent of our mind occupied by those anxieties and fears, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah, I mean, yeah. And you get to work on the business instead of in it, right? Like what, you get to work on building better systems and processes that reduce the amount of work that you have to do. But you don&#39;t do that. You don&#39;t, you know, that&#39;s what occupies our time, is the here and now, which is the relationships rather than how can I build a bridge for the future? And</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It&#39;s efficiency, it&#39;s effectiveness. It&#39;s just a great career, right? Like it&#39;s a great place to work if you can live within a team like that, like you can enjoy going. And that&#39;s always kind of my, getting back to my core purpose in life, I want to lift people up, I want to give them a good life. And so much of that is hard, either allowed or disallowed by the place that we work in. And I want people who work with me and work within an organization which I&#39;m in to have that ability and the ability to enjoy where they work, to be engaged, to not dread coming in or fear coming in and hoping that that adds years to their lives, right?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Absolutely. You know, and let&#39;s just add something to close on here, because building trust doesn&#39;t mean that you&#39;re just bubbly and happy all the time, right, but it allows for those crucial conversations, allows for the, for confrontation. You know, certainly, the place we work here in MedMan is amazing for that. And you know, one of the main reasons that really drew me in is this trust in the ability to feel like, you know, the leash is as long as I want to make it and I get to roam where I want to roam. But at the same time that is built on, I mean, you and I&#39;ve certainly had our fair and share of, you know, like with buttheads really hard where it hurts a while after, but after, you know, but in the moment you&#39;re like, we just need to do this, not for the sake of my pride or yours, but for us to get past this so that we don&#39;t add another weight to our shoulders that we have to carry around for another lifetime, right, which, which we do, so we get over it and then it&#39;s gone and it&#39;s like oh, we&#39;re moving on, we had to do that and we did it. And that takes time, but it really is the space that, and the understanding that the reason we get frustrated is because we both really, really care about doing great things and with that understanding, the association of being frustrated isn&#39;t I&#39;m frustrated at you Jesse, it&#39;s I&#39;m frustrated because I feel like this path is going to get to our goal better, and it&#39;s not me and you. It&#39;s a what decision or what path is right. And it makes all the difference, you know?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It does. And now, can I leave us on one way, one more, one additional way to build trust and you triggered it with me is that there have been lots of times like you said, where we, we&#39;ve ran into each other or I ran into it with one of our partners or whatever and come out on the other side trusting you guys more. And it&#39;s because of either, you know, you argue the ideology of the argument rather than the personal whatever, you know, the personal politics or you&#39;ve given me the forgiveness or grace afterwards if I&#39;ve overstepped. And that piece, you know, we&#39;re all going to have those confrontations. They are wonderful opportunities to build trust. Those are the areas where we enter the danger and come out better than, on the other side, and it&#39;s only because of your guys&#39; ability and willingness to forgive emotions, and give me grace to work within that that has happened, and it&#39;s what&#39;s developed, what I consider a super deep relationship amongst us partners, because of that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Amen, brother. And what a way to end this and for everyone out there, you know, thank you for tuning in, and Jesse, thank you for hanging out here and sharing your insights on trust.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Absolutely. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Everybody for the show notes, transcripts, and material from the show and really everything else MedMan does, why don&#39;t you head over to the website at MedMan.com and check things out? We&#39;re going to be here twice a week sharing insights, ideas, and tools to help you level up your practice. And again, thank you so much for hanging out with us.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guest. For the show notes, transcripts, resources, and everything else MedMan does to help you level up be sure to visit us at MedMan.com.</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="share transcripts" target="_blank" href="https://sonix.ai/features/share-and-publish?utm_source=embed">share transcripts</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="world-class support" target="_blank" href="https://sonix.ai/features/world-class-support?utm_source=embed">world-class support</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="upload many different filetypes" target="_blank" href="https://sonix.ai/list-of-languages-and-filetypes?utm_source=embed">upload many different filetypes</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="automated transcription" target="_blank" href="https://sonix.ai/features?utm_source=embed">automated transcription</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="BFizdQcpq1RbNLAN1pafYPEp" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","//sonix.ai/widget.js","//sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->

[/fusion_code] Episode Summary MedMan is back with another remarkable episode! In this episode, Jay and Jesse examine the
Q&A: People Management with Jesse Arnoldson
n [fusion_code]<!----- START CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->
<div class="sonix--embed-container" style="position:relative !important;display:block;overflow-x:hidden;min-height:504px;max-height:504px;overflow-y: hidden;"><div class="sonix--embed-text" style="min-height:504px;max-height:504px;text-align: left;overflow-y: scroll;"><h1 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;">The Medical Management Podcast_Q&amp;A. People Management: <a href="https://sonix.ai/?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio transcription service in 2021">Audio automatically transcribed by Sonix</a></h1><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;">The Medical Management Podcast_Q&amp;A. People Management: <a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix&#39;s converts the most popular audio file formats to text">this mp3 audio file </a>was <a href="https://sonix.ai/transcribe-audio?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best way to transcribe audio files in 2021">automatically transcribed by Sonix </a>with the <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="The best speech-to-text algorithms">best speech-to-text algorithms. </a>This transcript may contain errors. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Welcome to the Medical Management Podcast. A podcast focused on helping you level up your practice. Through interviews with some of the most successful leaders in the industry, we help uncover resources, tools, and ideas to help you level up your practice. Thanks for tuning in and we hope you enjoy today&#39;s program.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Hello and welcome to the Medical Management Podcast for MedMan, I&#39;m your host Jesse Arnoldson. Last episode we tried something a little bit different where we did a Q&amp;A session filled with some of the most frequent questions that we get over social media, email, and while we&#39;re in on-site, in some clinics. Last time we focused on recruitment and interviewing, this time we&#39;re going to focus on people management. I only have a couple of questions as I kind of pooled a number of these questions and put them together. But let&#39;s kick things off. The first one comes to us from somebody out of Utah, at a primary care clinic, it says, I feel like every time I turn around, someone is asking for a raise or leaving our clinic for just a dollar better in pay down the road. I don&#39;t feel like we pay unfairly, but it just seems to always be a problem. What should we do? This is a true issue, but I don&#39;t think that we look at it the right way. I think that, that we kind of allow our staff, our team members, to influence how we look at pay. For me personally, I see pay as you have to meet a minimum amount of pay and then you focus on other aspects of the position that help with whether you&#39;re feeling fulfilled, whether people care about you, whether you feel appreciated, whether you feel like you have the tools to be successful in your job, whether you like the people you work with, there&#39;s so many other things. Pay does not fix other issues. You can throw an extra dollar or two dollars, you can be that clinic that pays just a little bit more than anybody else down the road. But most of the time it&#39;s a symptom of an actual underlying issue. But it just gets painted with pay because people, what they&#39;ll do is, you know, I&#39;m going through all this stuff, I&#39;m struggling with this, I don&#39;t feel like I&#39;m doing great here, and for what? I can make an extra buck fifty down the road if I just make a switch. And so where I would start is first you do need to take a look at your pay scales. If you don&#39;t have pay scales, then that is maybe more of a problem than what I&#39;m alluding to. So, one, you need good pay scales that are backed up by actual data and you can get that data either from MGMA, your state&#39;s labor departments. You can go out and take a look at what other clinics are paying in their job postings. You can look at Salary.com, Glassdoor, Indeed. There&#39;s so many places that you can get good data to help you establish strong pay scales. And when I say pay scales is that you need to also, in addition to finding where you&#39;re going to anchor the pay, which is what all that data will help with, is figuring out, OK, how much are we going to pay for how much experience, how much schooling, how much this or that and being able to have a minimum, a maximum and then the different levels that you&#39;re going to move people up through. Once you&#39;ve established good pay scales with good data that you feel you can look somebody in the eye and justify, you need to stick with them. Far too often we let people negotiate better, the squeaky wheel gets the better pay, anything like that. And I&#39;m sorry, but I don&#39;t want to pay somebody simply because they&#39;re a better negotiator. I want to pay because they had great experience, I want to pay them for the education they have, I want to pay them for how, you know, effective they are in their job. The last thing is taking a look at the other things and digging deeper with these people to figure out what may be some of the other underlying issues are. There is one more thing that helped me a whole lot, as I&#39;ve been in different clinics, is I established a general philosophy around pay raises and what it would take to get a pay raise. And my philosophy is just one way, but I think having some set manner in which you can get a raise is helpful. I saw one of my favorite administrators of all time in Bend, Oregon, he established a merit-based way of getting paid more. And so he had different ways, different skills, different things, responsibilities you could take on, all these different pathways that as soon as you accomplish them, you could get a raise. And so it was up to you if you wanted to get a raise or not. I&#39;ve seen other people that have simply, you know, myself, I established three ways in which you could get a raise. One would be everybody gets their annual three percent increase or if your job description changes drastically, that&#39;s another way. If you take on a lead position or switch roles from front desk to care coordinator or you&#39;re a medical assistant, but then got your RN degree, sure, that can merit a pay raise. Finally, if we need to do a market adjustment, that can be an area that is understandable. Maybe our pay scales are lower than what fair market is. Or maybe we brought somebody in and placed them inside the pay scale unfairly. We didn&#39;t give them enough credit for their experience. That&#39;s the third way. So establishing and communicating what that method is for getting a pay raise is very important, in your onboarding, in your training, in your response, whenever somebody asks for a raise, you can go through one of these three ways or this is the way that you can get a raise. That&#39;s always really helpful. And in the end, just give yourself a break, because if you&#39;ve done all those things and somebody&#39;s still leaving for an extra dollar 50 raise down the road, sometimes it&#39;s just going to happen. And so to get a little bit easy on yourself and try in your hiring process to find somebody that maybe puts a little bit more weight on the other areas that you can control a little bit better, culture appreciation, giving them the right tools and training to feel successful in their job.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />All right, next question, what are some tips for delivering feedback? This is something that I&#39;ve seen a lot of lately, and maybe because Jay prompted me to read a book called The Coaching Habit, I&#39;ve been listening to a couple of different podcasts that just, you know, in a timely fashion, were about feedback and coaching and all that. It can be difficult depending on your personality, about whether or not you deliver feedback well. On one side, you can be this really nice person who far too often is scared to give feedback or won&#39;t give feedback because you don&#39;t want to hurt the person&#39;s feelings. On the other side of the coin, you have people that are just very direct and maybe a little bit lost in what direct should be and not be. I think I heard a fantastic podcast from Adam Grant where it&#39;s called working with a**holes. Being direct doesn&#39;t mean you have to be in a**hole. It can mean that you&#39;re demanding, that you require a high standard and the other people meet that, but it doesn&#39;t mean you need to be a jerk. And so I think that one, giving feedback has a lot to do with your own personal style. Tone, timing approach, these are all extremely important in how you&#39;re going to give feedback. But I don&#39;t think that there&#39;s a single way or a single personality that does it well. I think that there&#39;s just, depending on who you are, different tools, different skills, different approaches that can make you the best version of yourself possible. For me, I needed to get out of this headspace where giving feedback meant hurting somebody&#39;s feelings. I needed to understand that by painting a rosier picture than what reality was, was probably hurting the person more than just giving them good feedback early on. So one of it was just getting the right understanding of what feedback meant, that I was there to help that person rather than to just change them or to let them know how bad of a job they&#39;re doing or let them know what mistakes they&#39;re making. It really is me sitting next to this person and helping them solve our problem, not just their problem. The second thing was getting the courage to do so. These conversations, I&#39;m telling you, once you&#39;re in them and if you really care about the person and you&#39;re doing it to help them, quite often, just getting into it is the hardest part. And the conversation itself is a good one. And so you just need about eight seconds of courage to get in there and get the conversation started. Another big tip is timeliness. The sooner you approach something, the better. Giving something weeks, months, even waiting until their annual review to give feedback, quite often, the feedback does more damage than if you had just not said anything at all. And so if you can be in the moment and approach somebody if you can take care of the issue at the end of the day if you can have a monthly review that allows you to give feedback more often and for it to be expected, that can be really helpful. Lastly, ask yourself whether the feedback is actually going to help or not. Far too often people are like, yeah, I saw this person be a little bit short with a patient. OK, you know, how often does that happen? I&#39;ve never seen it before and this is the first time, or, whatever it may be. Sometimes you really have to ask yourself, is this feedback going to be helpful? Is it something that I really need to stop? Is it dangerous? Yes, I need to take it on. Those things can be really helpful because sometimes not everything needs to be said. Lastly, feedback has to be first-hand. Stop allowing people to bring you their issues with other people and for you to take them on, and with second-hand information, try and give somebody feedback.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />The next and last question is, how do I get rid of the drama? Somebody&#39;s always fighting with somebody. It&#39;s exhausting. I know I&#39;m the leader, but I just don&#39;t know how to fix the situation. So where I was going with that last bit on the feedback question, second-hand criticism can kill your culture. What I mean by that is so-and-so comes to me and says, hey, this person bit my head off, I want you to fix it, and maybe they don&#39;t say that last sentence, but that&#39;s what&#39;s implied. And so you go to person B and say, hey, you know, person A came to me and said, hey, you bit their head off. What do you mean I bit their head off? They were being a jerk, you know, and, oh, well, I didn&#39;t know that. And then you go back to person A, wait, you know I wasn&#39;t being a jerk, you know, it just, it compiles, people don&#39;t like to be talked about negatively, even if it&#39;s something that&#39;s their fault. And so the second that you bring up somebody else was talking about them, it causes their anxiety to go up, their blood pressure to go up, and they start looking for any reason to be defensive, to defend themselves. And so it doesn&#39;t help. It doesn&#39;t help. And so my personal philosophy has always been, OK, you know, that&#39;s a really crummy problem, I&#39;m going to coach you how to go back and talk with them. Let&#39;s talk about it. Let&#39;s talk about how you&#39;re going to address it with them, because this is important and OK, so here we go. I would go through and try and help them and then I would hold them accountable. Hey, I want you to talk to them today. Tomorrow morning I want to catch back up with you and see how it went. If you can get people to handle their first-hand problems themselves, trauma goes way down. It decreases the amount of work you have to do, and it actually solves the problems that they&#39;re having. If they&#39;re bringing them to you and you&#39;re allowing them to dump these problems off on your doorstep every time, one, it prevents you from doing your job; two, it creates complainers, because they just come to you, they drop a problem, they leave. They&#39;re like, oh, I did this before, I&#39;m going to go and drop another problem on Jesse&#39;s doorstep, and another one, and another one, to the point where they&#39;re just so critical of one another and bringing you all these complaints; third, it never solves the actual problem. You going with second-hand information is not going to work. Now, if it&#39;s something dangerous or absolutely inappropriate, let&#39;s say sexual advancements that are unwanted, sexual advances, or whatever it may be, something dangerous. Yes, you have to take care of that issue. But if it&#39;s just the normal run-of-the-mill critiques of one another, pushing back on them, having them solve those problems, that can decrease the amount of toxicity and drama in your culture.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Well, we&#39;ve reached the end of our Q&amp;A for this week. A reminder, last episode we talked about recruitment and interviews, this time talking about people management. I just want to encourage our listeners to send us questions. I would love to know what&#39;s going on in your clinic and how we can be of help, that can help us tailor our topics to be a little bit more applicable and custom fit for you. So please reach out to us over Facebook, LinkedIn, our website, you can reach any of us, we&#39;re first name@MedMan.com. My email is Jesse, J E S S E @MedMan.com. We also have a chat feature on our website. Send us questions about what you&#39;re facing in your clinics, we would love to address them! Before you go too far, make sure that you subscribe to the Medical Management Podcast so that you can stay tuned and up to date for the most current information that MedMan is putting out there. We&#39;ll see you next time!</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Thanks for tuning in to the Medical Management Podcast. We hope you enjoyed today&#39;s featured guest. For the show notes, transcripts, resources, and everything else MedMan does to help you level up, be sure to visit us at MedMan.com.</p><h2 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;"><a href="https://sonix.ai/?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best automated transcription service online">Sonix </a>is the world’s most advanced <a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription service">automated transcription, </a><a href="https://sonix.ai/translation?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated translation with Sonix">translation, and </a><a href="https://sonix.ai/automated-subtitles-and-captions?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easily create and edit subtitles with Sonix">subtitling platform. </a><a href="https://sonix.ai/fast-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription &amp; translation">Fast, </a><a href="https://sonix.ai/automated-transcription?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurate automated transcription &amp; translation">accurate, </a>and <a href="https://sonix.ai/pricing?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Affordable automated transcription &amp; translation">affordable. </a></h2><h3 style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your mp3 files to text">Automatically convert your mp3 files to text </a><a href="https://sonix.ai/how-to-convert-mp3-to-text?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to a txt file with Sonix">(txt file), </a><a href="https://sonix.ai/how-to-convert-mp3-to-docx?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to docx with Sonix">Microsoft Word (docx file), </a>and <a href="https://sonix.ai/how-to-convert-mp3-to-srt?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Accurately convert mp3 to srt with Sonix">SubRip Subtitle (srt file) </a>in minutes. </h3><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Best automated transcription, translation, and subtitling service">Sonix </a>has many features that you'd love including <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="enterprise-grade admin tools" target="_blank" href="https://sonix.ai/features/admin-tools?utm_source=embed">enterprise-grade admin tools</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="collaboration tools" target="_blank" href="https://sonix.ai/features/collaborate-with-teams?utm_source=embed">collaboration tools</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="automated translation" target="_blank" href="https://sonix.ai/features/automated-translation?utm_source=embed">automated translation</a>, <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="secure transcription and file storage" target="_blank" href="https://sonix.ai/features/security?utm_source=embed">secure transcription and file storage</a>, and <a href="https://sonix.ai/how-to-transcribe-a-zoom-meeting?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Quickly and accurately transcribe your Zoom meetings and recordings with Sonix">easily transcribe your Zoom meetings. </a><a href="https://sonix.ai/accounts/sign_up?utm_source=embed" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Try Sonix for free today">Try Sonix for free today. </a>

</p></div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="LdqheqJRWbe6EPkRfUzSmGHq" data-sonix-key="1592414274" style="position: absolute !important;top:0 !important;bottom: 0 !important;left: 0 !important; right: 0!important;"><div class="sonix--javascript"><script type="text/javascript">
  (function(s,o,n,i,x) {
    if(s[n])return;s[n]=true;
    var j=o.createElement('script');j.type='text/javascript',j.async=true,j.src=i,o.head.appendChild(j);
    var css=o.createElement("link");css.type="text/css",css.rel="stylesheet",css.href=x,o.head.appendChild(css)
  })(window,document, "__sonix","//sonix.ai/widget.js","//sonix.ai/widget.css");
</script></div></div></div>
<!----- END CODE — SONIX AUDIO EMBEDDABLE MEDIA PLAYER: www.sonix.ai ----->


[/fusion_code] Episode Summary People management can be one of the most difficult and important parts of a job.