Forem: Baby

Your Code Has Value: A Developer’s Guide to Salary Research (Without the Guesswork)

Baby — Sat, 04 Apr 2026 10:55:40 +0000

Stop relying on “levels.fyi” alone. Here’s how to combine data, human conversations, and a little bit of courage.

You’ve shipped features nobody thought possible. You’ve debugged at 2 AM, mentored juniors, and probably rewritten the same API three times. Yet when a recruiter asks, “What are your salary expectations?” – your mind goes blank.

I’ve been there. The temptation is to blurt out what you made at your last job plus 10%. But that’s how talented developers leave tens of thousands of dollars on the table.

The good news? Salary research for tech roles is easier than debugging a race condition. You just need a system. Let’s build yours.

Why “Just Look at Levels.fyi” Isn’t Enough

Yes, levels.fyi is amazing. So is Blind, TeamBlind, and all those anonymous salary threads. But they come with three problems:

Selection bias – People with huge salaries post more often
Missing location nuance – A Staff Engineer at a FAANG in Seattle is not the same as a Staff Engineer at a midsize remote-first company
No negotiation context – You see the number, not the story behind it (signing bonus? equity refresh? counter-offer?)

So let’s treat those sites as one data source, not the data source.

Step 1: Build Your “Dev Profile” – Honestly

Before you look at any external numbers, write down your tech stack proficiency and impact metrics:

Languages/frameworks (React, Python, Go, Rust, etc.) – be honest about years of professional use
System design experience (have you scaled a database? architected microservices?)
Business impact (e.g., “reduced API latency by 40%” or “saved $50k/year in cloud costs”)
Leadership (code reviews, mentoring, on-call rotation lead)

Why does this matter?

Because a React dev who only builds UI components is different from one who also sets up CI/CD pipelines and optimises bundle sizes. Your profile defines which salary band you fall into.

Step 2: Use Tech-Specific Salary Tools – Smartly

Now hit the usual suspects: levels.fyi, Glassdoor, Payscale, and LinkedIn Salary. But don’t just take the median. Filter by:

Company size (startup <50, mid-size, enterprise)
Years of experience (YOE) – and be strict here
Location (or remote policy)

Then, look for outliers.

If you see a senior frontend role paying $180k in a low-cost area, question it. Maybe it’s a contract role with no benefits. Maybe it’s a hyper-growth fintech.

To cross-check quickly without drowning in tabs, you can use a consolidated salary research tool. For example, usasalarytools.com aggregates data by state and job family – including tech roles – so you can spot regional trends without opening ten different websites.

The goal: a believable low-to-high range that you can defend with public data.

Step 3: The Remote Work Wrinkle (We All Hate It)

Remote has blurred everything. Some companies pay “national bands” (same salary for everyone in the US). Others pay based on your home address. How do you know what’s fair?

Do this:

Find three remote job postings for your exact title and seniority level (use We Work Remotely, Remotive, or LinkedIn remote filter). Note their salary ranges.

If one company pays $120k and another $160k for similar requirements, the lower one is either a budget startup or a geographic adjuster.

Then search for the same title but with a specific city (e.g., “Senior Software Engineer, Chicago”). Compare.

The difference between remote and on-site tells you exactly how much location flexibility is worth.

Step 4: Talk to Other Devs (Yes, It’s Awkward – Do It Anyway)

Data is dry. Humans are messy but real. You need to talk to at least one person who works (or worked) at your target company.

Send a DM on LinkedIn or Twitter (X) that sounds like this:

“Hey [Name], I see you’re a backend engineer at [Company]. I’m interviewing there soon and would love 5 mins of your time – not asking for your exact number, but any insight on how they structure levels or equity for someone with ~4 YOE? Totally understand if not.”

You’ll be shocked how many devs respond.

Most of us remember being underpaid and want to help.

They’ll tell you things no salary tool can:

“The bonus is almost never paid out”
“They’re desperate for Go devs – you have leverage”

Step 5: Build Your Negotiation Range – The 3-Number Rule for Devs

After collecting data, you’ll have a range that probably spans $30k (yes, tech ranges are wide). Now refine into three numbers:

Walk-away minimum – the base salary below which you’d rather keep interviewing
Target number – the fair, researched number that would make you excited to accept
Stretch number – target + 10–15% (or an extra $20k if you’re in big tech)

Your stretch number is what you ask for first.
Your target is where you hope to land.
Your walk-away protects you from signing an offer you’ll resent six months later.

Real-World Dev Example: From $115k to $142k

“Priya” was a full-stack developer with 3 YOE (React + Node). She got an offer for $115k from a Series B startup.

Her initial thought:

“That’s $10k more than my last job – great!”

But she spent one evening doing proper research.

Levels.fyi showed median for her YOE and city at $128k
The job asked for “experience with AWS Lambda” – a skill she had but hadn’t emphasised

She replied:

“Based on market data for full-stack devs with AWS experience and my track record, I was hoping for a range of $140k–$150k. Can we explore that?”

The recruiter came back at:

$135k base
$7k signing bonus

Total first-year comp: $142k

That’s a $27k difference for one email.

No aggressive tactics – just data and a calm ask.

What About Equity? (The Great Unknown)

Many devs obsess over base salary and ignore equity.

That’s a mistake — but also, equity can be worthless if the company never liquidates.

When evaluating equity, ask:

What’s the strike price vs. the current 409A valuation?
How many shares outstanding? (to calculate your % ownership)
What’s the liquidity preference? (preferred stock often gets paid first)
Is there a secondary market for shares?

If the recruiter can’t answer these clearly, treat the equity as a lottery ticket — nice to have, but not part of your walk-away math.

The “What’s Your Current Salary?” Trap – Especially for Devs

Recruiters still ask this. Even in tech.

Your answer should be:

“I’m focused on the value I’ll bring to this role, not my past compensation. Based on my research and the responsibilities here, I believe a fair range is $X–$Y.”

If they push (“we need to know for our system”), repeat the same line.

You are never, ever obligated to disclose previous pay.

Past underpayment is not a valid reason to underpay you again.

One Last Thing: Don’t Neglect Benefits

A lower base might still be a better total package if it includes:

401(k) match (typical 4–6% = thousands of dollars)
Health, dental, vision
Home office stipend, learning budget, conference travel
Unlimited PTO (which often means “no PTO” – ask the real usage)

Use a simple spreadsheet: add up the cash value of benefits, then compare total comp.

Sometimes the “lowball” offer is actually better.

Putting It All Together – For Your Next Interview

Here’s your 60-minute action plan before any salary conversation:

15 min – Self-audit: YOE, tech stack, impact metrics
20 min – Check 3 salary tools (levels.fyi, one general tool like usasalarytools.com, and LinkedIn)
10 min – Find 3 remote job postings for your role
10 min – Send 1 DM to a current/former employee
5 min – Write down your 3 numbers (walk-away, target, stretch)

That’s it.

One hour of research.

Then you walk into any negotiation with the quiet confidence of someone who knows their worth — not because a blog told you, but because you did the work.

Now go get what you deserve. 💻🚀

Enjoyed this? For more straightforward salary research – especially state-by-state and role-specific data – you can explore tools like *usasalarytools.com*. It’s not flashy, but it helps you cut through the noise when you just need a reliable number.

Why “Just 7 Minutes” Might Be the Most Powerful Productivity Trick Developers Aren’t Using

Baby — Fri, 27 Mar 2026 12:12:59 +0000

The hardest part of coding isn’t writing code — it’s starting

Let’s be honest.

You open your laptop to code… and somehow end up:

Scrolling Twitter/X
Watching YouTube
Overthinking architecture
Or just staring at your screen

It’s not because you’re lazy.

It’s not because you lack discipline.

It’s because your brain is resisting the start.

Most productivity advice for developers says:

Plan your tasks
Follow Pomodoro
Do deep work
Avoid distractions

Sounds great.

But in reality?

When you're mentally tired or stuck on a bug, even opening your editor feels like work.

So the real question is:

How do you make starting feel effortless?

🧠 The 7-Minute Rule (Simple but Effective)

The idea is simple:

👉 Commit to coding for just 7 minutes

That’s it.

No pressure to finish
No expectation of clean code
No perfect logic required

Just 7 minutes.

⚙️ Why This Works (Especially for Developers)

1. It reduces mental load

Your brain resists big tasks like:

“Build full feature”
“Fix entire bug”
“Complete project”

But:

“Code for 7 minutes” → feels easy

2. It creates flow state

Once you start coding:

You stop overthinking
You enter problem-solving mode
You forget time

Those 7 minutes often turn into 30+ minutes.

3. It kills perfectionism

Developers often delay starting because:

Code must be clean
Logic must be perfect
Structure must be scalable

But with 7 minutes:

You just write code. Imperfectly.

And that’s enough to begin.

4. It builds daily coding consistency

Even on bad days, you can code for 7 minutes.

And consistency >>> intensity.

🪜 How to Apply This While Coding

Step 1: Pick a small dev task

Fix a bug
Write a function
Refactor a small component
Read part of documentation

Step 2: Start a 7-minute timer

A timer removes decision fatigue.

You can use any timer, but a simple one works best for me is: 7MinuteTimer

(No login, no distractions — just start)

Step 3: Code immediately

No planning.

No overthinking.

Just open your editor and begin.

Step 4: Decide after 7 minutes

After the timer ends:

Continue (if you're in flow)
Stop (without guilt)

Either way, progress is made.

🎯 Real Developer Use Cases

🐛 Debugging

Stuck on a bug?

Start with 7 minutes — even reading logs helps break inertia.

🧱 Building side projects

Feeling overwhelmed?

Start small. One function. One component.

📚 Learning new tech

React, Node, TypeScript…

Instead of “learn everything,” just explore for 7 minutes.

✍️ Writing code/content

Docs, blogs, README…

Start writing for 7 minutes — clarity follows.

🚫 Common Mistakes Developers Make

❌ Waiting for motivation

Motivation comes after starting.

❌ Overengineering before starting

Don’t design everything upfront.

Start messy → improve later.

❌ Skipping timer

Without time constraint, your brain keeps delaying.

❌ Judging your code early

Bad code > no code

🧩 Why Simple Tools Matter

Developers love tools.

But too many tools = friction.

If your timer or productivity app:

Requires login
Has too many features
Distracts you

…it kills momentum.

That’s why minimal tools work better.

📈 Long-Term Impact

Imagine:

7 mins daily coding → real improvement
7 mins debugging → faster problem-solving
7 mins learning → skill growth

And most days, it won’t stay 7 minutes.

🧘 Final Thought

You don’t need:

More tutorials
More productivity hacks
More motivation

You just need to start.

👉 Just give it 7 minutes.

💡 Quick Dev Rule

Next time you're stuck, don’t ask:

❌ “How do I finish this feature?”

Ask:

✅ “Can I code this for just 7 minutes?”

🏷️ Tags

productivity #webdev #programming #beginners #selfimprovement

Rice Purity Test Explained: What It Is, How the Score Works, and Why People Still Take It

Baby — Mon, 09 Mar 2026 12:05:35 +0000

If you've spent time on the internet or in college communities, you may have heard someone mention their Rice Purity Test score*.

It’s one of those internet traditions that quietly survives year after year. Someone shares their score, curiosity spreads, and suddenly everyone around wants to try the test themselves.

But what exactly is the Rice Purity Test, and why has it remained popular for so long?

Let’s break it down.

What Is the Rice Purity Test?

The Rice Purity Test is a questionnaire that measures life experiences through a list of different situations people may encounter during their teenage or college years.

The test was originally created by students at Rice University as a lighthearted way to reflect on personal experiences and spark conversations among classmates.

Participants go through a checklist of experiences and mark the ones they have had.

At the end, the test generates a purity score between 0 and 100.

The higher the score, the fewer experiences someone has selected.

How the Rice Purity Test Works

The test typically contains a large list of questions related to life experiences, including areas like:

Relationships
Social interactions
Personal decisions
College life moments
Unexpected or awkward situations

Participants simply check the items that apply to them.

After submitting the checklist, the test calculates a score that represents the number of experiences selected.

If you're curious about how the questionnaire looks, you can see one version here:

https://rice-purity-test.online

The entire process usually takes only a few minutes to complete.

Understanding the Rice Purity Score

The score produced by the test ranges from 0 to 100.

While the number itself isn't meant to judge anyone, people often use it as a playful way to compare life experiences.

A general interpretation looks like this:

Score	Meaning
100	Very few experiences selected
90–70	Common experiences typical for many students
70–40	A wide range of life experiences
Below 40	Someone who has experienced many of the situations listed

It’s important to remember that the test is meant to be lighthearted rather than serious.

Why the Rice Purity Test Became Popular Online

Even though the test was created years ago, it continues to circulate on social media, forums, and college communities.

There are a few reasons why it spreads so easily.

1. It Sparks Curiosity

When someone shares their score, others immediately want to know their own.

2. It Starts Conversations

Many of the questions trigger funny memories or stories that people end up sharing.

3. It’s Quick and Easy

Unlike long personality quizzes, the Rice Purity Test takes only a few minutes.

4. It Feels Nostalgic

Many of the questions remind people of their school or college experiences.

Why People Compare Scores

One of the most interesting aspects of the Rice Purity Test is how people interact with it socially.

Instead of treating it as a serious personality test, people usually compare results with friends.

This often leads to:

Funny discussions
Surprising stories
Unexpected memories

In many cases, the conversations that follow are more entertaining than the score itself.

Should You Take the Rice Purity Test Seriously?

Not really.

The test was never intended to be a psychological evaluation or a personality assessment.

Instead, it works best as a casual reflection tool — something that encourages people to look back on their experiences and laugh about them.

Everyone’s life journey is different, and the test simply highlights that in a playful way.

Final Thoughts

The internet is filled with quizzes and viral trends that appear for a while and then disappear.

The Rice Purity Test, however, has managed to stay relevant for years.

Perhaps the reason is simple: it combines curiosity, nostalgia, and social interaction in a way that feels natural and fun.

And sometimes, something as simple as a list of questions can lead to surprisingly memorable conversations.

If you're curious about how the test works or want to see the questions yourself, you can explore it here:

https://rice-purity-test.online

Understanding Unicode Text Styles on the Web (Superscript, Small Caps, Fancy Text & More)

Baby — Sun, 08 Mar 2026 18:46:06 +0000

When we type on the internet, we usually use plain text from a standard keyboard. But if you look closely at posts, bios, and documents online, you'll often see text that looks different — smaller letters, raised numbers, decorative characters, or stylized fonts.

Examples:

x² or 10³ in math formulas
H₂O in chemistry
sᴍᴀʟʟ ᴄᴀᴘs in headings
ⓑⓤⓑⓑⓛⓔ style letters in social media captions

These are not actual fonts. They are Unicode characters.

Understanding how Unicode text styling works can be surprisingly useful for developers, writers, and anyone creating content online.

What is Unicode?

Unicode is a universal character encoding system designed to represent text from all writing systems in the world.

Instead of limiting text to just A–Z and numbers, Unicode includes thousands of characters such as:

mathematical symbols
language scripts
emoji
styled letters
superscript and subscript characters

Because of Unicode, text like this can exist:

ʰᵉˡˡᵒ
𝓗𝓮𝓵𝓵𝓸
Ⓗⓔⓛⓛⓞ
Ｈｅｌｌｏ

Each of these characters is actually a different Unicode symbol, not just a styled version of the same letter.

Why Unicode Text Styles Exist

Unicode text styles are commonly used for a variety of purposes:

1. Mathematics and Science

Superscripts and subscripts are essential for representing formulas.

Examples:

x²
10³
H₂O
CO₂

These appear in educational material, research notes, and documentation.

2. Writing and Content Formatting

Writers often use case transformations such as:

UPPER CASE
lower case
Title Case
Sentence case
aLtErNaTiNg CaSe

These help in formatting titles, headings, or emphasis.

3. Creative Text Styling

Many platforms support Unicode characters, allowing people to create stylized text such as:

sᴍᴀʟʟ ᴄᴀᴘs
𝓬𝓾𝓻𝓼𝓲𝓿𝓮
ⓑⓤⓑⓑⓛⓔ letters
Ｗｉｄｅｔｅｘｔ

These styles are often used in:

social media bios
captions
usernames
creative writing

How Unicode Text Generators Work

Most text styling tools follow a simple idea: character mapping.

They take a normal letter and replace it with a Unicode equivalent.

Example mapping:

a → ᵃ
b → ᵇ
c → ᶜ

So when someone types:

abc

The generator outputs:

ᵃᵇᶜ

Because these are real Unicode characters, they can be copied and pasted anywhere — websites, apps, documents, or messages.

Common Unicode Text Transformations

Here are some of the most commonly used transformations on the web.

Superscript

Used in mathematics and references.

Example:

x² + y³

Subscript

Used for chemistry formulas.

Example:

H₂O
CO₂

Small Caps

Example:

sᴍᴀʟʟ ᴄᴀᴘs

Often used for aesthetic headings.

Wide Text

Example:

ＷｉｄｅＴｅｘｔ

Trying Unicode Text Transformations

If you're curious about experimenting with these transformations, there are simple browser tools that demonstrate how these Unicode mappings work.

For example, this page shows several Unicode text transformations in one place:

https://www.superscript-generator.fun/

It includes things like superscript, subscript, case converters, decorative Unicode styles, and other text variations.

Why Developers Should Care About This

Even if you don't plan to use fancy text yourself, understanding Unicode transformations is helpful because it affects:

text processing
copy-paste behavior
search indexing
string comparison
input sanitization

For example, a visually similar character might actually be a completely different Unicode code point.

This can matter in areas like:

form validation
security checks
content moderation
search algorithms

Final Thoughts

Unicode quietly powers much of the text we see online. From superscripts in equations to decorative characters in social media, these symbols expand how text can be represented on the web.

For developers and content creators alike, understanding Unicode text transformations offers an interesting glimpse into how flexible modern text systems really are.