Preparing for Negotiation

Why preparation matters

In Researching Salary Ranges, you built market evidence. In Determining Your Personal Salary Range, you translated that market into your own floor, target, and stretch.

Now we move from numbers to readiness.

Preparation is where you decide:

• What strengths are most relevant
• Which proof points support your request
• Where you have leverage
• What you will do if the answer is no
• What tradeoffs you are willing to make

Think of this like a Steelers game plan: you do not script every play perfectly, but you know your strengths, your field position, and your options before the snap.

Preparation is an assembly step

You are not inventing your case from scratch. You are assembling what you already know into a negotiation-ready packet.

Market evidence  ┐
Personal range   ├──> Prep packet ──> Negotiation conversation
Value signals    │
Constraints      ┘

Your preparation should answer four questions:

1. What am I asking for?
   Use your range from the previous lesson.

2. Why is it reasonable?
   Use market data and business impact.

3. Why me?
   Use role-specific strengths and evidence.

4. What if they cannot meet it?
   Know your alternatives and tradeoffs.

The goal is not to memorize a speech. The goal is to make your thinking clear before pressure enters the room.

Leverage is relevance plus proof

A strength becomes leverage when it is both:

• Relevant to the employer's current needs
• Provable with credible evidence

For a senior developer, leverage often comes from things like reducing production risk, mentoring other engineers, shipping critical systems, or owning ambiguous work. A Stephen King fan might say: do not just claim you survived the haunted hotel; bring the maintenance logs.

Use a simple scoring model to decide which points deserve space in your preparation packet.

```cpp
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Signal {
    string name;
    int relevance;   // 1-5: how tied to employer needs?
    int proof;       // 1-5: how strong is the evidence?
    string evidence;
};

int main() {
    vector<Signal> signals = {
        {"Reduced production incidents", 5, 5, "Incidents down 38% over two quarters"},
        {"Mentored junior engineers", 4, 4, "Two engineers promoted after structured coaching"},
        {"Knows niche legacy system", 3, 5, "Primary maintainer for billing migration"},
        {"Great team culture fit", 3, 2, "Positive peer feedback, but limited metrics"}
    };

    sort(signals.begin(), signals.end(), [](const Signal& a, const Signal& b) {
        return a.relevance * a.proof > b.relevance * b.proof;
    });

    cout << "Top leverage signals:\n";
    for (const auto& s : signals) {
        cout << "- " << s.name
             << " | score=" << s.relevance * s.proof
             << " | evidence: " << s.evidence << '\n';
    }

    return 0;
}
```

You are preparing for a salary negotiation for a senior C++ role. Which point is the strongest leverage signal?

Turn evidence into a structured case

A persuasive preparation packet has a simple internal structure:

Claim        -> Evidence       -> Employer value       -> Request
I merit X       Because Y          Which helps Z            Therefore A

Example:

• Claim: My compensation should be at the upper part of the researched range.
• Evidence: I have led reliability work, reduced incidents, and mentored engineers.
• Employer value: This lowers operational risk and increases team capacity.
• Request: My target is aligned with that level of contribution.

Notice what this does: it keeps the request from sounding arbitrary. You are not saying, "pay me more because I want more." You are showing why the number belongs with the value delivered.

Your strongest alternative if no agreement is reached is often called your ____.

Anticipate objections before they arrive

Preparation includes identifying likely concerns and matching each one with evidence.

Do not script the whole conversation yet; the next lesson focuses on communication. For now, build a reference table so you are not surprised.

Common employer concerns:

• Budget constraints
• Internal equity
• Leveling or title mismatch
• Timing of review cycles
• Need for more proof of impact

Your job in preparation is to gather the clearest supporting material for each concern.

```cpp
#include <iostream>
#include <map>
#include <string>
#include <vector>

using namespace std;

int main() {
    map<string, vector<string>> prepCards = {
        {"Budget is tight", {
            "Know your acceptable range before entering",
            "List non-base tradeoffs you value",
            "Bring market data from your research brief"
        }},
        {"Need more proof of impact", {
            "Prepare metrics from recent projects",
            "Include before-and-after comparisons",
            "Identify stakeholders who can validate results"
        }},
        {"Level does not match request", {
            "Map responsibilities to higher-level expectations",
            "Show examples of scope, autonomy, and mentoring",
            "Clarify whether title adjustment is part of the path"
        }}
    };

    cout << "Objection prep cards:\n";
    for (const auto& [objection, actions] : prepCards) {
        cout << "\nConcern: " << objection << '\n';
        for (const auto& action : actions) {
            cout << "  - " << action << '\n';
        }
    }

    return 0;
}
```

True or false: You should prepare only one desired salary number because having a range weakens your position.

Know your boundaries before emotion rises

Preparation is not just about making the strongest case. It is also about protecting your decision quality.

Before negotiating, decide:

• Floor: the minimum acceptable outcome
• Target: the outcome you are aiming for
• Stretch: an ambitious but defensible outcome
• Tradeoffs: benefits, flexibility, bonus, title, learning, or timing that matter to you

You do not need every possible compensation detail resolved yet. Equity gets its own lesson later. For now, make sure your base decision boundaries are explicit.

```cpp
#include <iostream>
#include <string>

using namespace std;

string classifyOffer(int baseSalary, int floor, int target, int stretch) {
    if (baseSalary < floor) return "Below floor: prepare to decline or counter strongly";
    if (baseSalary < target) return "Acceptable zone: consider countering with evidence";
    if (baseSalary < stretch) return "Strong zone: evaluate full package and priorities";
    return "Stretch achieved: verify details and next steps";
}

int main() {
    int floor = 155000;
    int target = 170000;
    int stretch = 182000;

    int offers[] = {150000, 162000, 176000, 185000};

    cout << "Decision boundary check:\n";
    for (int offer : offers) {
        cout << "$" << offer << " -> "
             << classifyOffer(offer, floor, target, stretch) << '\n';
    }

    return 0;
}
```

Your negotiation prep packet

By the end of preparation, you should have a compact packet you can review before the conversation:

• Your researched market range
• Your personal floor, target, and stretch
• 3-5 strongest leverage signals
• Evidence for each signal
• Likely employer concerns
• Your BATNA
• Tradeoffs you value
• Decision boundaries for accept, counter, or walk away

This packet is your sideline play sheet. You may not use every item, but having it keeps you calm and deliberate.

Next, in Effective Communication in Negotiation, you will turn this preparation into a clear, professional conversation.