[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;"><h2 style="font-size:18px;color:#3E3E3B;text-decoration:none;font-weight:700;"><a href="https://sonix.ai/" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="&#39;The MedMan Podcast_ Getting Past Staff Complaints_Part 2&#39; transcript powered by Sonix. Sonix is the best automated transcription service in 2021. Easily convert your audio to text with Sonix.">The MedMan Podcast_ Getting Past Staff Complaints_Part 2 transcript powered by Sonix—easily convert your audio to text with Sonix.</a></h2><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:block;"><a href="https://sonix.ai/automated-transcription" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Automated transcription by Sonix: Best speech-to-text converter">The MedMan Podcast_ Getting Past Staff Complaints_Part 2 was automatically transcribed by Sonix with the latest audio-to-text algorithms. </a>This transcript may contain errors. <a href="https://sonix.ai/transcribe-audio?utm_source=embedplayer" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Sonix is the best audio automated transcription service in 2021.">Sonix is the best audio automated transcription service in 2021. </a><a href="https://sonix.ai/speech-to-text-all-supported-file-formats?utm_source=embedplayer" style="text-decoration:none;color:#3E3E3B;" target="_blank" title="Our automated transcription algorithms works with many of the popular audio file formats.">Our automated transcription algorithms works with many of the popular audio file formats. </a></p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Welcome to the MedMan podcast, a podcast focused on helping you level up your practice. I&#39;m Jesse Arnoldson. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And I&#39;m Jay Holmes through interviews with some of the most successful leaders in the industry. We help uncover resources, tools and ideas to help you level up. 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 />Hello, everybody, welcome to the MedMan podcast. I&#39;m Jay, I&#39;ll be your host today. This is the second part of us trying something new, really deep-diving into topics that are really top of mind. Today we have the pleasure of hearing from Jesse Arnoldson. Over these past couple of months, they&#39;ve been trying for all of us and experienced in some of our clinics just a little increase of complaining. Complaining, maybe whining. We&#39;re all getting worn down. Completely understandable. Jesse is going to talk to us today about some things you can do as a practice manager to help soften those complaints and help your team better direct better improve the culture. Jesse, welcome.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Hey, thanks, Jay. Appreciate it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So, yeah, let&#39;s just start this off. You know, just give us a little background of what you&#39;ve been experiencing, kind of what kind of signs or kind of push you to, hey, things are getting out of control or maybe just a little uncomfortable.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think the best summary I can give is that we were just feeling a lot of negativity in our practice. And as we felt that negativity more and more, it felt like we&#39;re kind of losing out on our culture that we had worked so hard to put together. And the signs, the initial signs that came up on my radar were mainly my feelings. You know, I can think of two specifically. One was that I started to dread talking one on one with my teammates. You know, any time somebody would pull me aside and say, hey, can we go talk in your office for a few minutes and start to get a knot in my stomach and get a little anxious just and my first thoughts like, oh, geez, you know, who are they upset about now? And that&#39;s not great. I didn&#39;t want to talk to anybody. That&#39;s a terrible feeling to have as the administrator. And then the second thing was that I started to feel myself get into the cycle as well. I caught myself talking to my wife, Hillary, one night and I was complaining about somebody else and how much they complain. And all of a sudden it just I just snapped out of it and realized I had fallen into the cycle as well. And so those two things made me think, is this just kind of some rough times because of all the things going on in 2020? Is it just a bad moment or is it something a little bit more serious and should we address it? And so I kind of reached out to a few other people in leadership team physicians just to kind of see how they were feeling without giving away what was on my mind. And the feedback was that they were kind of experiencing something similar. And so we started to lend some more thought to what it really was, what was causing it, and start to think about what we could do to address it. And when we got to the point of what&#39;s what&#39;s causing it. There were a number of things, but one of the things that we knew we could address, we can&#39;t do anything about the pandemic. We can keep working and trying and just, endure. We can&#39;t do anything about some of the external factors. But inside our practice, we can address this thing of complaints. That&#39;s something we think is probably having a major impact on, the positivity of our clinic as living up to the values that we hold so dear and in creating the kind of cohesive team we need to get through this and not get through, not just get through, but be successful through 2020 and beyond, is what we addressed. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Jesse was a certain area of the clinic or was it kind of widespread?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It was widespread at that point. And I can&#39;t pinpoint, maybe where it started. It just all of a sudden we turned around and realized we were kind of all in the same route.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And what do you think was missing in your and other management&#39;s response initially? What were the things that could you think that you were doing that might have enabled this?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think there&#39;s some normal pitfalls, for managers and people in leadership. And they want people to feel like they&#39;re being heard. They perhaps avoid it subconsciously or consciously avoid harder conversations. Sometimes they even agree on some of the things that they&#39;re complaining about. It&#39;s this kind of normal pitfalls that managers let themselves get into that not just allow this to happen, but promote it at a certain point. If you allow somebody to keep complaining and they&#39;re going to keep complaining, even more so and other people will see it and they&#39;ll start as well. It&#39;s a contagious thing.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />So just a snowball that they just picked up speed and got bigger and bigger. And so obviously one day it hit you, hit you in the face. What did you do? I&#39;m dying to hear. I&#39;m dying to hear what was the response and then how is the outcome?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />We did a couple of things. I&#39;ll focus on the second thing mostly. But the first thing we already had scheduled, we had set aside some time to start working on using our kind of personality profiles to better understand each other, better tailor our communication to one another and to better use conflict to get past hard things and make better decisions. And so, we already have that in the works and so we actually had one of our colleagues, Molly, come from MedMan and hang out at our practice a couple of days where she educated our team on personality characteristics and using, we use the disk profile, using those to better coordinate, better collaborate with each other. And so that&#39;s helped a ton. But other than that, we focused as a leadership team on what should be our approach to complaints, because I think that we all understood that if we just went out and said, you know, no more complaining, you&#39;re all a bunch of complainers. Oh my gosh. One, they would have stopped complaining to us, which great. But they wouldn&#39;t have stopped complaining. They would have just turned to each other or gone somewhere else to do so. There&#39;s no way they wouldn&#39;t take offense to that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />There&#39;s also a high likelihood that they would probably turn it around and say, well you&#39;re just as much of a complainer as we are. They&#39;ll probably be right. And so that, you know, we knew that wasn&#39;t the approach. So the approach that we or I guess the general consensus that we had was that the best way to turn this around was to have a process to address each and every one of these complaints that would teach the person bringing the complaint the appropriate manner in which to address this issue if that makes sense. And so we put some thought to paper on what that approach might look like and kind of gain some consensus on it. And then now we&#39;re beginning to use it as a leadership team. Every time somebody brings a complaint to us, we go through these different steps and think to ourselves, you know, are we doing this the right way? Helps us avoid those pitfalls, helps us teach them the appropriate way to do the appropriate things to bring to us appropriate things that we&#39;re going to address and has made things quite a bit better. We&#39;re at about a month and a half, two months now and seeing some progress.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Jesse tell me more. I want to know more steps, other things that you guys are doing. That sounds great.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />What we wanted to do is have some simple steps that we can have in the back of our mind that we could remember, that we would go through whenever a complaint was brought to us. And so we tried to make it something simple. And we came up with maybe like the five A&#39;s that we were going to. I know it&#39;s silly and cheesy and, you know, something straight out of a business book, but, you know, we have these to go through to help us as we&#39;re coaching the person in front of us. So, somebody brings us a complaint. The first thing that we should be thinking about is about the appropriateness of it. Is what they&#39;re bringing to us in the right tone. If it&#39;s something that sounds like gossip, headiness, something mean or even just venting, that&#39;s probably not appropriate. And you can&#39;t let it keep going. You got to stop it in its tracks. Something along the lines of, hey, I hear that you&#39;re frustrated. And I just the way that it&#39;s coming out, I want to address this in the right way. So let&#39;s make sure that we&#39;re not degrading the person. Let&#39;s make sure that we&#39;re being respectful, tell me more about what&#39;s going on.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />And I think it&#39;s really just setting the tone. And I know I mentioned this before to you and I don&#39;t want to put your name, but I read a book recently just trying to improve my parenting skills. And it&#39;s called Kids Are Worth It by a girl named Barbara. I think her last name is Coloroso. But she basically said, if someone&#39;s, the kid&#39;s going to come to you, you really ask the question, are you trying to get that other kid out of trouble or you try to get them in trouble and you set the tone right that if you&#39;re trying to get someone in trouble, there&#39;s no room for that. But if you&#39;re honestly trying to get another child, another kid out of trouble, we&#39;re going to sit down and talk about it. And that&#39;s what we need to talk about. But we don&#39;t need to hear you tattling on everyone else because you don&#39;t like how they&#39;re doing things. You can deal with that person in the moment. And that that really changes the dialogue and expectation. And does it take a while? You bet. But it certainly begins the transition of the expectation of the back and forth.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />It&#39;s exactly that Jay. And we like to think of us, as ourselves as adults and that we&#39;re beyond that but we&#39;re not. Tattling sounds childish, but that can be quite, exactly what it is. And so you have to address that first off and then you have to go through the next things like is this something that person should even be involved in? Is this even their mess? Is it something that&#39;s going to hurt the practice or the people around us, our patients, our team, then? If it is and let&#39;s keep moving. If it&#39;s not the kind of plays more towards, is this even an appropriate conversation to be having? Is that even a problem? And then have they addressed it with the other person? Quite often? If somebody is complaining to you Jay, you&#39;re not if you&#39;re the first person they are talking to you about it, you&#39;re probably not the right person to be talking to about. They are losing out on the opportunity to address it directly with that person in the moment, keeps it simple, helps you.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />You can fix that problem so much quicker, but if they don&#39;t and they hold on to it and then they bring in another person, it drives up the complexity, it becomes almost an unsolvable problem. And so you really have to,  next step is to ask, have they talked about that with the other person? Ninety-nine percent of the time Jay a complaint is one-sided. It really is. They haven&#39;t talked to the other person. They only have their view. You got to ask for more detail. You got to for specifics. And don&#39;t let somebody bring hyperbole to you. Have you ever had the conversation with somebody where they&#39;re like, this person does this all the time, they always, always talk to me this way. The hyperbole thing. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Too much. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Don&#39;t accept that. In specific cases, when did this happen? Has it happened before? When did it happen? Get in there. Because quite often it goes from always to well, you know, maybe once in December and then again last week, that&#39;s two times in a year. We&#39;re not really going to... </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Is that really always? Translate that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And then, moving along, the next thing is action. Making sure that they know that something has to happen at the end of this. Either you&#39;re going to do something or they&#39;re going to do something, because if not, then this turns back into Gaza, turns back into venting. And that&#39;s not OK. We have to have some sort of action come out of it. And then finally, who do you, I guess, now, finally. But the next one is who do you assign? Who&#39;s going to take that action? As a manager, you have to push back on 80 or 90 percent of the complaints that come your way and ask the person bringing it to you to do something about it. You can&#39;t let them just drop their problem off at your feet and let them go back without having any part in fixing it. Because if you do that, they&#39;ll bring you another one and somebody else will see that and bring you more until all of a sudden all the monkeys in the circus are sitting around you and nobody, you have too many problems you can&#39;t fix. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Yeah.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And then lastly is just accountability. I think one of the worst this is the equivalent of fumbling on the one-yard line is you&#39;ve addressed the appropriateness, you&#39;ve gotten all the detail. You&#39;ve asked them to do something about it and they&#39;re supposed to go do that. Where&#39;s the accountability? Where is the follow up to make sure they went and did that? Because far too often what they&#39;re bringing to you is kind of an uncomfortable thing. They don&#39;t want to have a hard conversation and so they&#39;ll let it go if they&#39;re allowed to. And so, you know Jay, I&#39;m glad you brought this to me. I need you to talk to so-and-so about this. I&#39;m going to come back to you tomorrow. I want to know how it went. Having something to keep their feet to the fire to make sure they do it. It helps them address the problem themselves, which is the most appropriate way to, thus kind of stop bringing you petty things. Because if this is what&#39;s going to happen if they&#39;re going to be forced into doing something hard, they&#39;re going to stop doing that. It&#39;ll teach them to bring appropriate things to you and to act appropriately in return. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Just the awesome stuff. I mean, all around, a couple of things that come to mind. I&#39;ve certainly been in experiences where there&#39;s been complaining about people in the organization. And I&#39;ve seen managers, in that moment say, awesome, let&#39;s go deal with that now and get up with the person and walk over to the other person and say, hey, we&#39;re going to have a talk about this. And that dramatically reduces those types of dialogues between the manager and their subordinates quickly, because it&#39;s not I&#39;m not going to solve your problem. It&#39;s going to oh, I&#39;m going to help you facilitate solve your problem. But it&#39;s your problem to solve. So let&#39;s solve. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I think that the first step, I would say that that&#39;s your second or third step. And let me give you the reason why is that it&#39;s the nuclear option. They don&#39;t want to do that. Oh, my gosh. It&#39;s so hard to get through those conversations. You&#39;ve been in them, I&#39;ve done the same thing. And the one thing that you risk is that then they won&#39;t bring real stuff. They&#39;ll have a hard time coming back to you again. And the first thing I think you offer up is, hey, go fix this on your own, keep it simple. Because and if they refuse to do so, if you check in on, if they say no or you check in on and then they say, no, I just couldn&#39;t do it. Then you&#39;re like, OK, well, then I&#39;m going to coach it. Like, let&#39;s go through it and do some scenarios. And if they still don&#39;t do it, then look, we&#39;ve got to get this fixed. I&#39;m bringing the other person in and we&#39;re going to talk about it. The reason why I say wait a couple of things before that is just whenever you have the manager get involved, it makes it a bigger deal. So if it was a small problem to begin with, no matter what it is, it gets amplified by having a manager there because the other person felt strongly enough to go and tell on you to the other person. So there better be a good reason. It&#39;s a fantastic tool and should be used. But try a couple of those other attempts to get them to fix on their own first. And I think you&#39;ll see hopefully some really good results from that.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I like it. I definitely like the approach. I&#39;m going to throw a curveball here, something that I&#39;ve heard that I really like. And I think it&#39;s just with relationships, in general, is that some people do want to vent. Some people just want to say, hey I want to just get this off my chest or someone&#39;s weight on me. And oftentimes through just advice that I&#39;ve gotten, you often ask that person coming to you, are you looking for advice or you just want to vent or you look for empathy or advice. And we&#39;re human beings. I think it&#39;s hard to not allow venting in the right setting. Because sometimes it&#39;s some people that&#39;s just their natural way of letting steam off. Yeah. And some people don&#39;t want advice. Some people just say, no, I just need to get this out of my chest and I&#39;ll be good. Is there a place for that? And if so, where does that sit?</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Oh man, I&#39;m in the middle of trying to form a good opinion around this. Like I&#39;ve been giving this a lot of thought because venting quite often is a sign of burnout. And what I&#39;ve been taught about that is that the more you allow the symptoms of burnout to continue, the more burned out and the further down the person gets in the path of burnout. And so by letting them vent like it doesn&#39;t, if somebody is truly experiencing burnout, venting doesn&#39;t help. In fact, it strengthens the problem. And so I look for that. I think that that&#39;s something to look for. If you see somebody that&#39;s constantly venting, that can be a problem.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Because really what, you&#39;re wasting energy on not solving the problem.</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>Jay Holmes: </strong><br />But just avoiding it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Exactly. Now if you&#39;re not if you know, Jay, you and I know each other pretty well. We can tell when we&#39;re up and when we&#39;re down. But if you were to come to me and just say, hey, man, I just need to get this off my chest because some crazy manager, doctor, whoever is giving me a hard time. Yeah. Let&#39;s talk. Of course, you&#39;re looking for empathy. I&#39;m going to be there for you. I think it&#39;s trying to determine whether the venting is coming from a place of just needing a little bit of empathy, empathy to get back up or a place of burnout. And that can help you decide whether venting is a good thing or not. And then the last couple of things, it&#39;s important that it&#39;s done the right way to the right person. I don&#39;t especially managers definitely can&#39;t vent down and team members definitely shouldn&#39;t vent sideways. So, I mean, it should be coming to you. And I love the question that you asked. Do you want advice or empathy? Like that, that&#39;s probably a good thing. And then the last thing to watch out for is every time somebody goes into your office and closes the door if that happens, more and more the people outside that see that wonder that it leaves room for them to wonder if it&#39;s about them. And so it can create a space again for mistrust and paranoia to take root. And so just be very careful with how many times you let people take you aside and whisper things and talk about it quietly, because other people, it can leave other people wondering the worst. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Totally. It&#39;s kind of like, you know, you certainly can&#39;t say, hey, there&#39;s absolutely no venting prohibited here. But it&#39;s almost that, it&#39;s a sign that speaks to maybe a week in culture. And so the goal is to limit those occurrences, not to say, of course, they&#39;ll never happen. But if they happen more and more, it&#39;s certainly a symptom of eroding culture because things can&#39;t be handled between people, which they really should.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />And venting is just a long complaint.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Absolutely. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />That&#39;s all it is, is just a much longer complaint. And so back to the original thing. We took a look at our values Jay, and our values, our cohesive team, simplicity, growth mindset, life balance and gratitude. And out of the five, you know, I went through and thought about how complaining affects each of those. For example, cohesive team. If you&#39;re complaining, you&#39;re probably complaining about a person and you can&#39;t develop a sincere functioning relationship with somebody that you&#39;re feeling that negative about, you know, in simplicity. If you&#39;re complaining and once you&#39;ve involved a third person, a fourth person into the problem, every time you add somebody to it, it becomes more complex and harder to solve. So it flies right in the face of simplicity. If you&#39;re complaining, you&#39;re definitely looking outward, which means you&#39;re not looking inward, which means you&#39;re not growing. You&#39;re becoming more and more numb to the things you need to fix. And so your growth mindset is shattered. And then finally, on the gratitude side, complaining is just inherent, inherently negative. Have you ever heard a positive complaint? Those don&#39;t exist. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />I just have too many days off from work. I just, I hate it.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />I have too much money in our... people are too nice to me. It doesn&#39;t exist. So it&#39;s inherently negative. The more negative you feel and the more negativity you push off, there&#39;s no way for you to be able to see the good things around you, let alone to be grateful for them. And so it just we spend all this time thinking about our values. Sometimes we need to think about the things that are an antithesis to our values the anti-values. Complaining is definitely one of them. If it&#39;s not a value, it&#39;s an action and it&#39;s powerful negative action that you have to address. You can&#39;t just let it go because it will never stay small. If you allow it to exist, it will grow and grow and erode your culture like you said earlier. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />Jesse, I&#39;m loving that you linked this back to your values. It&#39;s music to my ears. Certainly, values should drive most everything that we deal with. And as far as culture and people. So nice work. And listeners out there, I encourage you to kind of work through this game plan here, because it&#39;s certainly helping Jesse. And it&#39;s got some legs to work for you as well. So, Jesse, a big thank you for sharing that insight and helping all of us deal with those complainers out there.</p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />Absolutely. Thank you Jay. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jay Holmes: </strong><br />OK, so thank you all for tuning in today. I hope you enjoyed our conversation with Jesse. I sure did. For the show notes, transcripts, material from the show and everything else MedMan does head over to the website at MedMan.com. Remember, we&#39;ll be here twice a 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 the MedMan podcast, we hope you enjoyed today&#39;s featured guest. </p><p style="font-size: 14px;color: #3E3E3B;text-decoration: none;"><strong>Jesse Arnoldson: </strong><br />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/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Automatically convert your audio files to text with Sonix">Automatically convert your audio files to text with Sonix. </a><a href="https://sonix.ai/automated-transcription" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix is the best online, automated transcription service.">Sonix is the best online, automated transcription service. </a></h2><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;"><a href="https://sonix.ai/how-to-convert-mp3-to-text" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Convert mp3 to text with Sonix">Sonix uses cutting-edge artificial intelligence to convert your mp3 files to text. </a></p>
<p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;">More computing power makes audio-to-text faster and more efficient. <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="Sonix is the best automated transcription service and supports over 40 different languages; transcribe your audio files today. " target="_blank" href="https://sonix.ai/languages">Sonix is the best automated transcription service and supports over 40 different languages; transcribe your audio files today. </a>Use Sonix to simplify your audio workflow. <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="Sonix accurately converts most popular audio file formats (like WAV, MP3, OGG, and AIF) to text. " target="_blank" href="https://sonix.ai/audio-to-text-file-formats">Sonix accurately converts most popular audio file formats (like WAV, MP3, OGG, and AIF) to text. </a>Let powerful computers do the work for you; automated transcription in minutes. <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="Transcription agencies are able to better serve their customers by using Sonix&#39;s automated transcription in the back office. " target="_blank" href="https://sonix.ai/transcription-agencies">Transcription agencies are able to better serve their customers by using Sonix&#39;s automated transcription in the back office. </a></p><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;">Sonix takes transcription to a whole new level. <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="Automated transcription for all of your company recordings; Sonix is built for the enterprise. " target="_blank" href="https://sonix.ai/enterprise">Automated transcription for all of your company recordings; Sonix is built for the enterprise. </a>Save time and money with automated transcription. <a style="font-size: 14px;color: #3E3E3B;text-decoration: none;" title="Make your audio files more accessible with Sonix&#39;s automated transcription algorithms. " target="_blank" href="https://sonix.ai/accessibility">Make your audio files more accessible with Sonix&#39;s automated transcription algorithms. </a></p><h3 style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;font-weight:400;"><a href="https://sonix.ai/best-mp3-to-text-converter?utm_source=embedplayer" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Convert mp3 to text with Sonix">Sonix uses cutting-edge artificial intelligence to convert your mp3 files to text. </a></h3><p style="font-size: 14px;line-height: 18px;color: #3E3E3B;text-decoration: none;display:inline;font-weight:400;">Sonix is the best online audio transcription software in 2021—it's <a href="https://sonix.ai/speed?utm_source=embedplayer" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Fast automated transcription with Sonix">fast</a>, <a href="https://sonix.ai/features?utm_source=embedplayer" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Easiest way to transcribe audio with Sonix">easy</a>, and <a href="https://sonix.ai/pricing?utm_source=embedplayer" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Cheap automated transcription with Sonix">affordable</a>. </p><p style="font-size:14px!important;color:#3E3E3B!important;text-decoration:none!important;display:inline;">If you are looking for a great way to <a href="https://sonix.ai/features" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="convert audio to text">convert your audio to text</a>, <a href="https://sonix.ai/" style="font-size: 14px;color: #3E3E3B;text-decoration: none;" target="_blank" title="Sonix: Audio and video transcription powered by cutting-edge AI">try Sonix today. </a></p>

</div><div class="sonix--embeddable sonix-embed" data-disable-analytics="false" data-sonix-id="a2dtstMRnd2x2XftrR6h8oR5" 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 :
- Personality profiles can be really handy when trying to understand other people.
- Managers might have pitfalls, but you need to make sure you have the correct approach to provide a better outcome.
- Keep things respectful.
- Understand that complaints usually one-sided, make sure you ask for specifics.