The Salary Script That Actually Works (No Fluff)

Quick context (why you're writing this)

I remember the first time I got an offer after a grueling interview loop. The recruiter threw a number at me that felt…off. I hesitated, mumbled something about “looking for something competitive,” and ended up leaving $15k on the table. I kicked myself for weeks. After that, I started treating salary talk like any other engineering problem: define the inputs, run the numbers, and produce a precise output. The moment I stopped being vague and started handing over a concrete, data‑backed figure, my offers jumped. Here’s the exact script that made the difference.

The Insight

Anchor with a single, precise number that’s justified by market data and your own impact.

Ranges (“I’m looking for $120‑$130k”) give the employer wiggle room to pull you down to the low end. Vague asks (“I want to be paid fairly”) give them no concrete target to work against. A specific figure forces the conversation to revolve around that number, and when you back it up with credible data, it’s hard for them to dismiss it without looking unreasonable.

Why does this work? It’s the same principle we use when we set a hard limit in code: if you give a function a clear input, you get a predictable output. The employer’s brain treats your number as a reference point (the “anchor”) and adjusts from there—usually upward, because moving down feels like a loss.

How (with code)

Below is a tiny Python‑ish snippet that mirrors the thought process behind the script. It’s not meant to be run; it’s just a way to show the logic and where most people slip up.

def market_target(role, years, location):
    # Pull median salary from a trusted source (e.g., Levels.fyi, Glassdoor)
    median = get_market_median(role, years, location)
    # Add a premium for proven impact — adjust as you see fit
    impact_bonus = 0.10 if has_leadership_impact else 0.05
    return int(median * (1 + impact_bonus))

def build_negotiation_line(offer, target):
    if offer >= target:
        return f"Thanks for the offer of ${offer:,}. It looks aligned with my expectations."
    # The exact wording I use — notice the precision and the justification
    return (f"Thank you for the offer of ${offer:,}. "
            f"Based on current market data for {role} in {location} "
            f"and my specific contributions (e.g., {key_achievement}), "
            f"I’m targeting a base salary of ${target:,}. "
            f"Is there flexibility to adjust the offer toward that number?")

What the script looks like in practice

You: “Thank you for the offer of $115,000. Based on current market data for a Senior Backend Engineer in New York and my specific contributions—like leading the migration that cut our latency by 40% and mentoring three junior engineers—I’m targeting a base salary of $130,000. Is there flexibility to adjust the offer toward that number?”

Common mistakes (the “buggy” versions)

Mistake 1 – Vague range

def bad_line(offer):
    return f"Thanks for the offer. I was thinking something in the $110k-$130k range?"

Why it fails: The employer hears the low end first and often counters near $110k. You’ve already given them permission to lowball you.

Mistake 2 – No justification

def bad_line2(offer):
    return f"Thanks for the offer. I was hoping for something higher, maybe $130k?"

Why it fails: “Higher” is subjective. Without data or impact tied to the number, it feels like a personal preference, not a market‑driven request.

Mistake 3 – Apologetic tone

def bad_line3(offer):
    return f"Sorry to bother you, but would you consider maybe $130k? I totally understand if not."

Why it fails: You’ve weakened your position before the conversation even starts. Confidence (not arrogance) signals that you know your worth.

Why This Matters

Using a precise, justified anchor does three things:

1. Sets the tone – You frame the negotiation as a data‑driven discussion, not a haggling match.
2. Reduces back‑and‑forth – The employer either moves toward your number or provides a clear counter‑with‑reason, which you can then evaluate against your own data.
3. Boosts outcomes – In my own experience and in the data I’ve seen from peers, candidates who open with a single, well‑supported number tend to land 8‑15% higher than those who start with a range or a vague ask.

It’s not a magic bullet—if the company truly can’t meet your number, you’ll need to decide whether to walk away or negotiate other components (equity, remote days, signing bonus). But you’ll know exactly where you stand, and you won’t leave money on the table because you were too timid to name a figure.

Actionable next step

Before your next offer conversation, do this:

1. Spend 20 minutes pulling median salary data for your role, years of experience, and location from two reputable sources (e.g., Levels.fyi, Payscale, or your company’s internal bands if you have them).
2. Identify one concrete achievement that moved the needle for your team or product (performance improvement, cost saving, mentorship, etc.).
3. Plug those into the script above (or just copy the exact wording) and practice saying it out loud—yes, actually say it aloud a couple of times. Notice how it feels.

Then, when the offer arrives, use that line. If you get a counter, repeat the process: reference the data, reiterate your impact, and see if they can move. If they can’t, you’ll have a clear picture of whether the total package still meets your goals.

---

Give it a try. Next time you’re negotiating, drop the exact line and see what happens. Did it shift the conversation? Did you feel more confident? Drop a comment below with your experience—let’s learn from each other’s real‑world results. 🚀