{"!!WARNING!!":"해당 내용은 스모어 서비스(smore.im) 제공을 위해서만 사용 가능합니다. 무단 복제 및 사용을 금합니다.","url":"https://doda.app/quiz/3Q90UwtMPO","font":"Open Sans","count":"8","share":{"targets":{"f":true,"k":false,"l":true,"m":true,"t":true,"w":true},"hashtags":["Quiz","Doda","Made_With_Doda"],"shareResult":false},"colors":{"key":"rgba(156, 39, 176, 1)","background":"rgba(255, 255, 255, 1)"},"editor":{"customTheme":{"key":"rgba(156, 39, 176, 1)","blur":false,"background":"rgba(255, 255, 255, 1)","brightness":false},"editorIndex":7,"nowThemeIndex":999},"quizzes":[{"a":[{"a":"True","c":["Compromising","Avoiding","Accommodating"],"key":"1","weight":[1,1,1]},{"a":"False","c":["Competitive","Collaborative"],"key":"2","weight":[1,1]}],"q":"You believe the best outcome is one that works equally well for either party...","key":"rGiy♥A♠♛","type":"","image":null},{"a":[{"a":"I tell them their offer is unacceptable.","c":[],"key":"1","weight":[]},{"a":"I make a counteroffer &#128073; 10% raise but more vacation time...","c":[],"key":"2","weight":[]},{"a":"I ask them about the reasoning behind their offer.","c":[],"key":"♜ДJO5XC2","weight":[]},{"a":"I accept their offer without negotiating for more time off.","c":["Avoiding","Accommodating"],"key":"KLДZw☎C6","weight":[1,1]}],"q":"A prospective employer offers you a 15% raise but next to no vacation time","key":"Ta♣e⍩JB♚","type":"","image":null},{"a":[{"a":"I tell them to cancel their other appointment...","c":[],"key":"1","weight":[]},{"a":"I ask them if they're willing to push back their appointment","c":[],"key":"2","weight":[]},{"a":"It's okay but I've done everything myself","c":["Compromising","Avoiding"],"key":"3","weight":[1,1]},{"a":"I let them cut to the chase.","c":[],"key":"4","weight":[]}],"q":"In the middle of negotiation, the other party says they need to cut to the chase...","key":"⍤2⍣9e7ez","type":"","image":null},{"a":[{"a":"15K – It's the absolute highest I can go.","c":["Competitive","Accommodating"],"key":"1","weight":[1,1]},{"a":"12-15K – I aim for mid-budget.","c":[],"key":"2","weight":[]},{"a":"10-12K – Let's start from the bottom!&nbsp;","c":[],"key":"Q☁♟C♟r☂4","weight":[]},{"a":"Under 10K – I'm looking to save serious $ on this contract...&nbsp;","c":[],"key":"bn⍨B⍡50K","weight":[]}],"q":"In negotiation, You have 10-15K, but their quote for this contract is 17K","key":"DwXKyZҔx","type":"","image":null},{"a":[{"a":"Excited – The other party and I have come up with a creative solution to our problem...","c":[],"key":"1","weight":[]},{"a":"Anxious – Ugh, I don't know if I asked for enough.","c":["Avoiding","Accommodating"],"key":"2","weight":[1,1]},{"a":"Fired up - I just got everything I wanted. Another win for yours truly &#10024;&#129395;&nbsp;","c":[],"key":"Nq4P♠♦♦V","weight":[]},{"a":"Content – The other party and I came to a reasonable agreement.&nbsp;","c":[],"key":"⍩Qw☁♞⍩w3","weight":[]}],"q":"How do you usually feel after negotiating?","key":"♠☺Д8Фo⍡n","type":"","image":null},{"a":[{"a":"True","c":["Compromising","Avoiding","Accommodating"],"key":"1","weight":[1,1,1]},{"a":"False","c":["Competitive","Collaborative"],"key":"2","weight":[1,1]}],"q":"You're willing to give a little more if it means less negotiating...","key":"tYѴrҔ1Y♚","type":"","image":null}],"restart":{"text":"Retake Quiz"},"results":["Collaborative","Compromising","Competitive","Accommodating","Avoiding"],"animType":0,"editable":false,"nowIndex":0,"userPlan":2,"multiLang":[],"published":1,"rpVersion":1,"startPage":{"image":"https://ddstatic.net/1646899335773-0739093.jpg","button":{"icon":"chevron_right","text":"Take Quiz"},"showCount":false,"showShare":true},"useRandom":true,"quizResult":{"result":"Avoiding"},"buttonTheme":1,"description":{"lang":"en","logo":null,"type":"Type","title":"What's your negotiation style?","shortLink":null,"description":"Discover which of the negotiating styles suits your personality","useShortLink":false},"loadingPage":{"text":"Analyzing","delay":4000,"completeText":"Completed"},"resultPages":{"Avoiding":{"key":"jwX9hhfw","image":"","title":"Avoiding","sortKey":0,"contents":"<p>Friend, you're not a fan of negotiating. Your version of solving the problem is avoiding it for as long as possible. While this can sometimes be advantageous, if you're not careful, it could lead to conflicts down the road.Quick tip: to overcome your fear of negotiating, do some research! Find out which of the other styles resonate the most with you then read up on their unique techniques. With a bit of practice, you're sure to get there, too!“Everything is negotiable. Whether or not the negotiation is easy is another thing.” – Carrie FisherThree Quick ‘n Easy Tips for Painless Negotiations&#128071;1) Manage Your MindsetFriend, if you’re new to negotiation, be careful not to approach it as if it's an argument. Negotiation is simply a discussion between individuals seeking a mutually beneficial outcome – it doesn't have to get heated. Plus treating it like a conflict might cause you to behave unnecessarily aggressive or tense. Instead, demonstrate your warmth and patience to whoever you’re negotiating with. Listen carefully to their needs, and if they don’t align with yours, be prepared to respectfully decline.2) Prepare, Prepare, Prepare&#128070;Somethings are so important you have to say them three times… Do not show up to a negotiation without doing your homework. Find out the other party’s needs, pressures, and options. This’ll help you make well-informed decisions.On top of that, reflect on your own goals for the negotiation. Try asking yourself questions like ‘What’s my ideal outcome?’ and ‘Where am I willing to compromise?’ When the time comes, you’ll be likelier to stay true to your goals having thought about them in advance.3) Don’t Take it PersonallyTry to view negotiations as business transactions. This’ll help ease some of your insecurities about what the other person may be thinking. Remember, their opinions are none of your business. What’s most important is coming to a mutually beneficial outcome.Don’t let what you’ve learned about the other party cloud your critical thinking abilities. Just because they might represent a large company, doesn’t mean you should feel intimidated.Wait a Sec – Let Me Introduce MyselfHey there, I’m Anna Nelson &#128075; I’m a career coach who specializes in training freelancers to negotiate for higher pay.More than anything, I want you to realize your worth and ask for it on a consistent basis. If you’re ready to start treating your time and energy like the precious resources they are, my services are for you &#128588;&#10024;Extra Resources to Smooth Over Your Negotiation? Read On...1) Check out this blog post where I show you my office-friendly outfit go-tos. Hint: it’s so much more than boring button-downs and pleated slacks.2) Listen to me speak on this podcast episode. I fill host Natalie Ramon in on my personal experience working as a freelance creative.3) Book a free consultation with me. If you think we’d be a good match, don’t hesitate to reach out. Let’s give this thing a go! P.S. Expect to See Me in Your Inbox with Insights on Your Negotiation Style!</p>","topTitle":"Your style is...","twitterTags":[]},"Competitive":{"key":"l3IDiHjF","image":"","title":"Competitive","sortKey":2,"contents":"<p>Friend, when it comes to negotiating, you've got no time for pleasantries. You skip the small talk and cut right to the chase. This means you get results QUICK. On top of that, once you decide on your ideal outcome, you're unwavering.Quick tip: your aggressive drive and determination might be a teensy bit off-putting at times, so don't be afraid to soften your approach. Competitive is a common negotiation style, so it's relatively easy to counteract.“Everything is negotiable. Whether or not the negotiation is easy is another thing.” – Carrie FisherThree Quick ‘n Easy Tips for Painless Negotiations&#128071;1) Manage Your MindsetFriend, if you’re new to negotiation, be careful not to approach it as if it's an argument. Negotiation is simply a discussion between individuals seeking a mutually beneficial outcome – it doesn't have to get heated. Plus treating it like a conflict might cause you to behave unnecessarily aggressive or tense.Instead, demonstrate your warmth and patience to whoever you’re negotiating with. Listen carefully to their needs, and if they don’t align with yours, be prepared to respectfully decline.2) Prepare, Prepare, Prepare&#128070;Somethings are so important you have to say them three times… Do not show up to a negotiation without doing your homework. Find out the other party’s needs, pressures, and options. This’ll help you make well-informed decisions.On top of that, reflect on your own goals for the negotiation. Try asking yourself questions like ‘What’s my ideal outcome?’ and ‘Where am I willing to compromise?’ When the time comes, you’ll be likelier to stay true to your goals having thought about them in advance.3) Don’t Take it PersonallyTry to view negotiations as business transactions. This’ll help ease some of your insecurities about what the other person may be thinking. Remember, their opinions are none of your business. What’s most important is coming to a mutually beneficial outcome.Don’t let what you’ve learned about the other party cloud your critical thinking abilities. Just because they might represent a large company, doesn’t mean you should feel intimidated.Wait a Sec – Let Me Introduce MyselfHey there, I’m Anna Nelson &#128075; I’m a career coach who specializes in training freelancers to negotiate for higher pay.More than anything, I want you to realize your worth and ask for it on a consistent basis. If you’re ready to start treating your time and energy like the precious resources they are, my services are for you &#128588;&#10024;Extra Resources to Smooth Over Your Negotiation? Read On...1) Check out this blog post where I show you my office-friendly outfit go-tos. Hint: it’s so much more than boring button-downs and pleated slacks.2) Listen to me speak on this podcast episode. I fill host Natalie Ramon in on my personal experience working as a freelance creative.3) Book a free consultation with me. If you think we’d be a good match, don’t hesitate to reach out. Let’s give this thing a go!P.S. Expect to See Me in Your Inbox with Insights on Your Negotiation Style!</p>","topTitle":"Your style is...","twitterTags":[]},"Compromising":{"key":"6X6TEx9O","image":null,"title":"Compromising","sortKey":4,"contents":"<p>Friend, you're dead-set on finding the middle ground. You enter into negotiations determined to find a solution that benefits both parties equally. You understand that a good outcome is one that ends in camaraderie – not competition.Quick tip: even if you don't feel 100% comfortable negotiating, try to take your time instead of settling as soon as you and the other party reach an agreement. There might be a more creative option!“Everything is negotiable. Whether or not the negotiation is easy is another thing.” – Carrie FisherThree Quick ‘n Easy Tips for Painless Negotiations&#128071;1) Manage Your MindsetFriend, if you’re new to negotiation, be careful not to approach it as if it's an argument. Negotiation is simply a discussion between individuals seeking a mutually beneficial outcome – it doesn't have to get heated. Plus treating it like a conflict might cause you to behave unnecessarily aggressive or tense.Instead, demonstrate your warmth and patience to whoever you’re negotiating with. Listen carefully to their needs, and if they don’t align with yours, be prepared to respectfully decline.2) Prepare, Prepare, Prepare&#128070;Somethings are so important you have to say them three times… Do not show up to a negotiation without doing your homework. Find out the other party’s needs, pressures, and options. This’ll help you make well-informed decisions.On top of that, reflect on your own goals for the negotiation. Try asking yourself questions like ‘What’s my ideal outcome?’ and ‘Where am I willing to compromise?’ When the time comes, you’ll be likelier to stay true to your goals having thought about them in advance.3) Don’t Take it PersonallyTry to view negotiations as business transactions. This’ll help ease some of your insecurities about what the other person may be thinking. Remember, their opinions are none of your business. What’s most important is coming to a mutually beneficial outcome.Don’t let what you’ve learned about the other party cloud your critical thinking abilities. Just because they might represent a large company, doesn’t mean you should feel intimidated.Wait a Sec – Let Me Introduce MyselfHey there, I’m Anna Nelson &#128075; I’m a career coach who specializes in training freelancers to negotiate for higher pay.More than anything, I want you to realize your worth and ask for it on a consistent basis. If you’re ready to start treating your time and energy like the precious resources they are, my services are for you &#128588;&#10024;Extra Resources to Smooth Over Your Negotiation? Read On...1) Check out this blog post where I show you my office-friendly outfit go-tos. Hint: it’s so much more than boring button-downs and pleated slacks.2) Listen to me speak on this podcast episode. I fill host Natalie Ramon in on my personal experience working as a freelance creative.3) Book a free consultation with me. If you think we’d be a good match, don’t hesitate to reach out. Let’s give this thing a go! P.S. Expect to See Me in Your Inbox with Insights on Your Negotiation Style!</p>","topTitle":"Your style is...","twitterTags":[]},"Accommodating":{"key":"T2f8Mscv","image":"","title":"Accommodating","sortKey":1,"contents":"<p>Friend, you're always looking for ways to help the other party. You make sure their needs are taken care of – sometimes even more so than your own. You expect they'll reciprocate your generosity, but they've got other ideas...Quick tip: you could afford to be a little less generous. Even when you feel stingy, odds are you're giving more than most would.“Everything is negotiable. Whether or not the negotiation is easy is another thing.” – Carrie FisherThree Quick ‘n Easy Tips for Painless Negotiations&#128071;1) Manage Your MindsetFriend, if you’re new to negotiation, be careful not to approach it as if it's an argument. Negotiation is simply a discussion between individuals seeking a mutually beneficial outcome – it doesn't have to get heated. Plus treating it like a conflict might cause you to behave unnecessarily aggressive or tense.Instead, demonstrate your warmth and patience to whoever you’re negotiating with. Listen carefully to their needs, and if they don’t align with yours, be prepared to respectfully decline.2) Prepare, Prepare, Prepare&#128070;Somethings are so important you have to say them three times… Do not show up to a negotiation without doing your homework. Find out the other party’s needs, pressures, and options. This’ll help you make well-informed decisions.On top of that, reflect on your own goals for the negotiation. Try asking yourself questions like ‘What’s my ideal outcome?’ and ‘Where am I willing to compromise?’ When the time comes, you’ll be likelier to stay true to your goals having thought about them in advance.3) Don’t Take it PersonallyTry to view negotiations as business transactions. This’ll help ease some of your insecurities about what the other person may be thinking. Remember, their opinions are none of your business. What’s most important is coming to a mutually beneficial outcome.Don’t let what you’ve learned about the other party cloud your critical thinking abilities. Just because they might represent a large company, doesn’t mean you should feel intimidated.Wait a Sec – Let Me Introduce MyselfHey there, I’m Anna Nelson &#128075; I’m a career coach who specializes in training freelancers to negotiate for higher pay.More than anything, I want you to realize your worth and ask for it on a consistent basis. If you’re ready to start treating your time and energy like the precious resources they are, my services are for you &#128588;&#10024;Extra Resources to Smooth Over Your Negotiation? Read On...1) Check out this blog post where I show you my office-friendly outfit go-tos. Hint: it’s so much more than boring button-downs and pleated slacks.2) Listen to me speak on this podcast episode. I fill host Natalie Ramon in on my personal experience working as a freelance creative.3) Book a free consultation with me. If you think we’d be a good match, don’t hesitate to reach out. Let’s give this thing a go!P.S. Expect to See Me in Your Inbox with Insights on Your Negotiation Style!</p>","topTitle":"Your style is...","twitterTags":[]},"Collaborative":{"key":"TntZnu9o","image":null,"title":"Collaborative","sortKey":3,"contents":"<p>Friend, you turn negotiation into a creative art. You come up with innovative solutions to the problems no one else can crack. You're sensitive to the other party's interests and involve them in your process whenever possible.Quick tip: if you're coming up with a solution in cahoots with another party, be careful not to give too much away. It's easy to get a little too comfortable and hand over confidential information.“Everything is negotiable. Whether or not the negotiation is easy is another thing.” – Carrie FisherThree Quick ‘n Easy Tips for Painless Negotiations&#128071;1) Manage Your MindsetFriend, if you’re new to negotiation, be careful not to approach it as if it's an argument. Negotiation is simply a discussion between individuals seeking a mutually beneficial outcome – it doesn't have to get heated. Plus treating it like a conflict might cause you to behave unnecessarily aggressive or tense.Instead, demonstrate your warmth and patience to whoever you’re negotiating with. Listen carefully to their needs, and if they don’t align with yours, be prepared to respectfully decline.2) Prepare, Prepare, Prepare&#128070;Somethings are so important you have to say them three times… Do not show up to a negotiation without doing your homework. Find out the other party’s needs, pressures, and options. This’ll help you make well-informed decisions.On top of that, reflect on your own goals for the negotiation. Try asking yourself questions like ‘What’s my ideal outcome?’ and ‘Where am I willing to compromise?’ When the time comes, you’ll be likelier to stay true to your goals having thought about them in advance.3) Don’t Take it PersonallyTry to view negotiations as business transactions. This’ll help ease some of your insecurities about what the other person may be thinking. Remember, their opinions are none of your business. What’s most important is coming to a mutually beneficial outcome.Don’t let what you’ve learned about the other party cloud your critical thinking abilities. Just because they might represent a large company, doesn’t mean you should feel intimidated.Wait a Sec – Let Me Introduce MyselfHey there, I’m Anna Nelson &#128075; I’m a career coach who specializes in training freelancers to negotiate for higher pay.More than anything, I want you to realize your worth and ask for it on a consistent basis. If you’re ready to start treating your time and energy like the precious resources they are, my services are for you &#128588;&#10024;Extra Resources to Smooth Over Your Negotiation? Read On...1) Check out this blog post where I show you my office-friendly outfit go-tos. Hint: it’s so much more than boring button-downs and pleated slacks.2) Listen to me speak on this podcast episode. I fill host Natalie Ramon in on my personal experience working as a freelance creative.3) Book a free consultation with me. If you think we’d be a good match, don’t hesitate to reach out. Let’s give this thing a go!P.S. Expect to See Me in Your Inbox with Insights on Your Negotiation Style!</p>","topTitle":"Your style is...","twitterTags":[]}},"hideDodaLogo":false,"questionLayout":"text","showAllResults":false,"backgroundImage":null,"resultPageTheme":1,"nowQuestionIndex":1,"resultPageShareText":"Share with friends","userId":16,"isFreeUpgrade":false}