LinkedIn notes for engineers who would rather build than post. 🔗

Sourcing is a search query, not browsing

Recruiters run keyword searches across your headline, About section, experience descriptions, and skills, then filter by location, seniority, and current company. If the words in the query are not somewhere in your profile, you do not exist for that role. That is why keyword advice exists, and it is also why it stops being useful the second you start stuffing words in dishonestly.

• Open five job posts you would genuinely accept. Copy out every technology, methodology, and role noun that repeats across them.
• Anything on that list you can defend in an interview belongs somewhere in your profile, inside a real sentence.
• Anything you cannot defend stays off. A search hit you fail in the first ten minutes of a screen costs you the relationship, not just the role.
• Spell things the way the industry does, both ways where both exist: Node.js and Node, Kubernetes and K8s, TypeScript and TS, CI/CD and continuous delivery.

Your job title has to match what people search for

Internal ladders are invisible outside your company. Nobody searches for Member of Technical Staff, IC3, or Engineer II, so a profile carrying only the internal label quietly drops out of the results. Keep the real title on record and make the market title obvious as well.

• Title field: keep whatever the company officially calls the role.
• Description: open with a plain reading of it, for example that this was a senior backend role on payments infrastructure.
• Headline: use the market title, since that field is entirely yours to control.
• Replace anything like Various Roles or See Description in older entries with the actual title. A vague history removes you from searches about your own experience.

Location is a filter, and a blank one costs you

Location behaves like a dropdown, not a sentence. A recruiter hiring in a city filters to that city, and a profile set to a whole country, a tiny suburb, or nothing at all falls out of those results even when the candidate fits perfectly.

• Pick the recognized metro label rather than the neighbourhood you live in.
• If you are targeting remote roles in another country, say so in the headline or About, because the location field alone cannot express it.
• Keep your open to work preferences aligned with this, since those fields get filtered on too.

Completeness moves you up the list, quietly

LinkedIn keeps a private read on how complete your profile is, and completeness feeds into how results get ordered, alongside skills, endorsements, and how close you are to the searcher in the network. You cannot see that score and you should not try to game it. You can simply stop leaving whole sections empty, which is what most engineers do.

• Fill these for almost everyone: photo, headline, About, every role with a description, education, skills, and a couple of recommendations.
• An experience entry with a title and no description is the most common gap on engineer profiles, and it is the field that holds the most searchable text.
• Add entries for internships, freelance work, and open source you genuinely maintain. That is experience, and it is searchable.

Check that you are visible outside LinkedIn at all

Two settings get confused constantly. Public profile visibility controls whether search engines and people who are not logged in can see you. Private browsing controls only whether others learn that you looked at them. Private browsing hides nothing from recruiters, and switching public visibility off hides you from a lot of them.

• If you are open to being approached, keep public visibility on and let your headline, About, and experience show publicly.
• Private browsing has one real cost: you stop seeing who viewed your profile, which is useful signal during a search.
• While you are in the settings, claim a clean custom profile URL and use that link on your resume, GitHub, and site.

The first forty characters are the ones most people see

In search results, comments, and notifications your headline gets cut short, so the front of it has to survive alone. Put your role and your primary stack right at the start, and push the softer material to the end where truncation cannot hurt you.

Formulas you can fill in right now

Every strong engineer headline I have seen is one of a handful of shapes. Pick the shape that matches your situation, fill in the blanks, then read it back and ask whether a recruiter hiring for your next role would nod.

• Working, not looking: [Role] at [Company] | [Stack] | [What you build]
• Working, quietly open: [Role] | [Stack] | [Domain or scale detail]
• Actively searching: [Role] open to [level] roles | [Stack] | [Location or remote preference]
• Switching fields: [Target role] | [Stack you can already defend] | previously in [Old field]
• Filled in: Frontend Engineer at Acme | React, TypeScript, Next.js | design systems and web performance
• Filled in: Backend Engineer open to senior roles | Go, PostgreSQL, Kubernetes | payments at scale, Bengaluru or remote

Words that cost you nothing to delete

Some phrases weaken a headline because they describe how you feel rather than what you can do. Others just eat characters that keywords need. Cut them and the same headline gets clearer and more searchable at the same time.

• Cut: aspiring, enthusiast, passionate about technology, tech geek, lifelong learner.
• Cut: ninja, rockstar, guru, and anything that would embarrass you if it were read aloud in a hiring meeting.
• Cut long emoji chains and separator art. One symbol is a style choice; six is noise pushing your keywords out of view.
• Cut standalone vague nouns like Developer. Frontend Engineer, Backend Engineer, Data Engineer, SRE, and Mobile Engineer are what people actually type.
• Keep: your real title, three or four named technologies, one concrete domain, and a plain statement that you are open if you are.

Say you are open plainly, if you are

There is nothing undignified about stating that you are looking, and it helps the recruiters who filter for exactly that. What fails is making availability the whole headline. Open to opportunities, on its own, gives a searcher nothing to match against a role.

• Weak: Immediate joiner | Open to any opportunity | Willing to relocate anywhere
• Stronger: Backend Engineer open to mid level roles | Java, Spring, AWS | 30 day notice period
• Rewrite it the week you accept an offer. A stale open to work headline on a happily employed engineer reads as neglect.

Front load it, because the opening lines are the whole battle

Whatever sits above the cutoff has to earn the tap. Start with what you do and what you are good at, in a plain sentence. The origin story, the hobbies, and the gratitude paragraph belong at the bottom, if anywhere.

A skeleton you can fill in tonight

Five short paragraphs, none longer than three lines. This holds up whether you are two years in or twelve, and it gives search something to bite on without ever looking like a keyword list.

• Opening line: what you do now, in plain words, with your main stack named.
• Second paragraph: the kind of problems you work on, with one concrete detail about scale, users, latency, uptime, or team size.
• Third paragraph: two or three specific things you have shipped, each with the outcome attached.
• Fourth paragraph: how you work, in one honest sentence. Testing habits, code review, design docs, mentoring, whatever is genuinely true of you.
• Fifth paragraph: what you want next, and how to reach you. One line each.
• Optional closing line: a short readable list of tools, so the words exist on the page for search without hijacking the prose.

Write for a competent stranger, not a keyword parser

My test is simple. Would a senior engineer at a company you want to join read this and think, yes, I understand what this person does and I could place them on a team? Buzzword soup fails that test even when it ranks well.

• Weak: Results driven software professional leveraging cutting edge technologies to deliver innovative solutions.
• Stronger: I build and maintain the billing services at a payments company. Most of my work is keeping money movement correct under load, which means a lot of idempotency, reconciliation, and deliberately boring code.
• Weak: Passionate about crafting seamless user experiences.
• Stronger: I care most about the parts of frontend nobody sees: bundle size, render cost, and the accessibility work that makes a product usable on a cheap phone and a slow network.

End with a clear invitation

Most profiles simply stop, without telling the reader what to do next. One line fixes it, and it is the difference between a recruiter who saves you and one who moves on. Say what you are open to, and say how to start the conversation.

• If you are searching: name the role, the level, the locations, and your notice period.
• If you are not searching: say what you will happily talk about anyway, for example infrastructure problems or mentoring.
• Give one reliable channel. If your inbox here is a mess, say email, and put the address in your contact fields.

Open every role with one line of context

Before any achievement, say what the team owned, who used it, and roughly how big it was. Resume bullets skip this because there is no room. Without it, an outsider cannot tell whether your work was hard, and hard is exactly what they are trying to assess.

• Template: [Team or product] serving [users or scale], built on [stack]. I owned [your area].
• Filled in: Checkout team at a marketplace doing about two million orders a month, on Java and Kafka. I owned the order state machine and the retry layer.
• One line, then move straight on to what you actually did.

Rewrite bullets so the outcome is visible

The pattern is the same one that works on a resume, with room to breathe: what you changed, how you changed it, and what happened as a result. If you have no number, describe the before and after state instead. Invented metrics fall apart the moment someone asks a follow up question.

• Before: Responsible for improving application performance using React best practices.
• After: Cut the dashboard's first load from about nine seconds to under three by splitting the bundle, deferring chart rendering, and removing two duplicate data fetches. Support tickets about the page timing out stopped.
• Before: Worked on migrating the monolith to microservices.
• After: Extracted the notifications service out of the monolith, moved it behind a queue, and ran both paths in parallel for six weeks before cutting over. No notifications were lost during the migration.
• No number available? Say what was broken, what you did, and what became possible afterwards. That is still evidence.

Attach skills to the specific role

You can associate skills with an individual position rather than only with the profile as a whole. Small action, real value: it ties a technology to a period, a company, and a described piece of work, instead of leaving it floating as an unsupported claim.

• For each role, attach the five or six technologies you genuinely used there.
• Keep them consistent with the words in that role's description. A skill appearing nowhere in the prose looks decorative.

Show the whole history, including the awkward parts

Gaps and short stints look worse hidden than explained. Sourcers notice unexplained holes because their tooling puts dates front and center. One calm sentence removes the question entirely.

• Career break: use the dedicated entry type and give it one honest sentence. Study, caregiving, health, layoff, relocation, all of it is ordinary.
• Contract and freelance work: create a real entry with a real title and list clients in the description, rather than leaving a blank stretch of time.
• Layoff: you owe no explanation in the profile itself. Keep the dates accurate and let the work speak.

Aim for six hundred to nine hundred characters per recent role

Long enough to give context and two or three real outcomes. Short enough that someone skimming on a phone reaches the end. Older roles can shrink to a line, because nobody is hiring you for what you did seven years ago.

• Current role: full treatment, one context line plus three or four outcomes.
• Previous two roles: one context line plus two outcomes each.
• Anything older: title, company, dates, and a single line.

Choose twenty to thirty skills, and pin what you want to be hired for

You can list up to a hundred and you should not. A long list dilutes what you are known for and invites endorsements from people who have never seen you work. Pin the few you want to be searched and remembered for, because those are the ones shown first.

• Build the list from the job posts you collected earlier, not from memory.
• Include the unglamorous words too: SQL, Git, REST, Docker, CI, observability, whatever is genuinely part of your day.
• Drop anything you last touched four years ago and would not want to be interviewed on.
• Pin your primary language, your main framework, and one specializm, for example TypeScript, React, and web performance.

Endorsements are cheap, recommendations are not

An endorsement is one click from someone who may know nothing about your work, so nobody weights them heavily. A written recommendation from a manager or a teammate who watched you ship something is the closest thing your profile has to a reference, and almost no engineer bothers to collect a single one.

• Target one or two written recommendations for each of your last two roles. Beyond that they go unread.
• Ask people who saw specific work: your tech lead, the manager who scoped a project with you, someone you paired with for months.
• Endorse others honestly and specifically in return. It is the cheapest reciprocity available here.

A recommendation request people actually answer

These requests get ignored because they ask a busy person to invent content from nothing. Do the remembering for them. Name the project, name your contribution, and state the length you expect, so the task feels finished before they begin.

• Hi [Name], I am tidying up my profile and would really value a short recommendation from you.
• If it helps, the thing I would point to is the [project] work: I [what you did] and it [outcome].
• Three or four sentences is plenty, and please only write what you actually think. Happy to write one for you as well.

Featured is the one place you can show the artifact

Everything else on the profile is you describing your work. Featured is where you show it. Three items is the right number, chosen so a stranger can verify in two minutes that you are what you claim to be.

• Good candidates: a repository you can explain line by line, a technical post you wrote, a live project, a talk recording, a written case study.
• Bad candidates: certificate images, screenshots of course dashboards, anything you could not discuss for ten minutes.
• Whatever you feature, make sure its own README or first paragraph is readable. A great repository with no explanation converts nobody.

Photo, banner, and the fields nobody notices are missing

None of this wins you a job, and all of it costs one evening. The point is to remove small reasons for a stranger to hesitate. Treat it as hygiene, do it once, then stop thinking about it.

• Photo: recent, your face filling most of the frame, plain background, looking at the camera. A phone and a window is enough.
• Banner: a flat color or something related to your work. Anything beats the default, which reads as an abandoned profile.
• Contact info: add your email, your GitHub, and your site if you have one.
• Certifications and education: fill in what is real and leave the rest empty. An empty field is neutral, an inflated one is fatal.
• Before a big rewrite, switch off sharing profile updates with your network, so twenty edits do not become twenty notifications.

Two settings, two different bets

One shares your interest with recruiters privately. The other adds the visible frame to your photo and tells everyone, including your current colleagues. The private option is the one almost nobody thinks about, and the one most employed engineers should be using.

• Recruiters only: visible inside recruiter tooling, not on your public profile. LinkedIn tries to keep it from recruiters at your current employer and says openly that it cannot guarantee that.
• All members: the green frame, visible to your manager, your teammates, and everybody else.
• Either way, fill in the preference fields underneath: target titles, locations, remote or onsite, job types, start timing. Those feed the filters recruiters search on, and they work with the frame switched off.

What the numbers actually support

LinkedIn's own data says people flagged as open receive noticeably more recruiter messages, and that recruiters get considerably better reply rates from them, which is precisely why sourcers filter for the flag. The visibility effect is real. It is not a placebo.

Where the criticism is fair

Plenty of recruiters and career coaches genuinely think the public frame reads as desperation, and some argue it invites weaker offers because it signals you have no alternatives. My read is that the effect is smaller than the discourse suggests, and that it shrank a lot once the layoff waves made public job searching completely ordinary. But it is not zero, and it grows the longer the frame stays up.

What I tell mentees

Match the setting to the truth of your situation, then revisit it every few weeks. The mistake is rarely picking the wrong option. It is picking one and forgetting it exists.

• Employed and quietly curious: recruiters only, preferences filled in, no frame.
• Employed and actively leaving: recruiters only, and do the outreach yourself instead of waiting to be found.
• Out of work and needing volume: turn the frame on. Visibility beats optics when you have no pipeline.
• Senior or well networked: skip the frame and spend that energy on twenty direct conversations.
• Whatever you choose, switch it off the day you sign. A stale flag is the loudest thing on a neglected profile.

The useful connections sit in the middle band

Opportunities rarely arrive from your closest friends, who know roughly what you know, or from total strangers, who have no reason to help. They come from the layer in between: former colleagues, someone you met once at a meetup, an engineer you have exchanged three good comments with. That is where new information lives.

• Highest value additions: people you actually worked with, people who interviewed you, people working in your stack, engineers at the ten companies you would like to join.
• Low value additions: motivational accounts, mass connectors, and anyone whose posts you would mute on sight.
• Follow instead of connecting when you only want someone's writing. Following costs them nothing and keeps your network meaningful.

Volume has a real cost

Mass invitations are not a neutral strategy. LinkedIn watches how many of your invitations sit ignored or get marked as unknown, and it restricts sending when that ratio looks bad. Restrictions arrive without warning, usually in the exact week you need the account working.

• Send fewer invitations than you feel like sending, and personalize the ones you care about.
• Withdraw requests that have sat unanswered for a month. A large pile of pending invitations works against you.
• Personalized notes are capped on free accounts and the exact limit keeps moving, so treat every note as scarce rather than firing off twenty identical greetings.

Ten minutes a week keeps it alive

A network you only touch when you need something is not a network, it is a list. The maintenance is genuinely small, and doing it while you are employed and comfortable is what makes the eventual search short.

• Congratulate former colleagues on real moves, in one specific sentence rather than the suggested reply.
• Leave one substantive comment somewhere you actually know something. This is how quiet people become known.
• Message one person you have lost touch with, with no ask attached. Do this before you need anything.
• When somebody helps you, tell them what happened. It is the entire reason people help a second time.

Prune it once a year

You will accumulate recruiters for roles you never wanted, vendors, and accounts that post nothing but engagement bait. Removing them is not rude, and it changes what you see. A feed full of noise is the main reason engineers walk away from the platform entirely.

Short beats polished, by a lot

The data LinkedIn publishes about its own recruiter messages is blunt: messages under roughly four hundred characters get meaningfully better response rates than average, and messages over twelve hundred do measurably worse. The same asymmetry applies to you. Long messages read as work. Short ones read as a question.

• Target four or five short lines. If it does not fit on a phone screen without scrolling, cut it.
• One ask per message. Two asks means the reader has to decide twice, so they decide never.
• Write it, then delete the first sentence. It is almost always a warm up you do not need.

The shape that works

Four moves, in order: who you are in one line, why you are writing to this specific person, one small and specific ask, and a graceful exit that makes ignoring you costless. The exit matters more than people expect. It is what turns a message into a question rather than a demand.

• Line one: who you are, with the detail that makes you relevant to them.
• Line two: why it is them, drawn from something real. Their team, their talk, their post, their open role.
• Line three: the ask, sized so that answering takes under five minutes.
• Line four: the exit. No problem at all if you are busy.

Templates you can adapt

Use these as scaffolding, not scripts. The specific detail in the second line is the entire message; everything else is packaging. If you cannot write that line honestly, you have picked the wrong person.

• Connection note: Hi [Name], I work on [your area] and have been following how [their team] handled [specific thing]. Would like to stay connected.
• Asking about a team: Hi [Name], I am a [role] working mostly in [stack]. I saw [Company] is hiring a [role] on your team, and before applying I wanted to ask one thing: what does the first six months in that role actually look like? Two lines is plenty. No problem if you are busy.
• Reaching a hiring manager: Hi [Name], I have applied for [role] on your team. Quick context in case it is useful: I spent the last two years on [closely related work], including [one specific outcome]. Happy to send anything that would help, and equally happy to let the application run its course.
• Following up once: Hi [Name], floating this back up in case it got buried. Completely fine if now is not a good time.
• After they help: Hi [Name], quick update. I spoke to [team] and [what happened]. Thank you for pointing me there, it made a real difference.

Never ask a stranger for a referral in the first message

A referral is a reputational loan. You are asking someone to put their name next to yours inside a system where their judgement gets scored. Somebody who has never spoken to you cannot do that honestly, so asking immediately puts them in an awkward position and usually earns silence.

• If they do not know you, ask for information first: their honest read on the team, or what the interview loop is like.
• If a real conversation happens, the referral is often offered without you asking for it.
• If it is not offered, you can ask directly at the end of that conversation and it will not feel like an ambush.

Make the referral itself a two minute job

When you do ask, hand over everything the person needs in one message, so helping you costs them a copy and a paste. The most common reason a willing referrer never follows through is that the request left them with homework.

• Include the exact job link or requisition number. Never make them go and find the role.
• Include three lines on why you fit, written so they can paste them straight into the internal form.
• Attach or link the exact resume you are submitting for that role.
• Mention the deadline if there is one, and say plainly that no is a fine answer.
• Template: Hi [Name], would you be willing to refer me for [role, with link]? Three lines you can reuse: [line one], [line two], [line three]. Resume attached. Genuinely fine if you would rather not, I know a referral carries your name on it.

Volume, done honestly

Twenty thoughtful messages will outperform three hundred copies of one message, and they will not get your account restricted. Keep a list, track who replied, and stop after a single follow up. Persistence past that point is not tenacity, it is a bad first impression.

• Five to ten genuinely personalized messages a week is a sustainable pace during an active search.
• One follow up after about a week. Then stop, permanently.
• Track it somewhere simple: person, company, role, date sent, reply, next step. Your memory will not hold this for six weeks.

Who actually needs to post

Posting pays off when your goal depends on strangers knowing you exist: consulting, developer relations, hiring for your own team, speaking, building an audience for something you sell. If your goal is a good engineering job at a company with a recruiting function, it is a nice to have and nothing more.

Comment before you ever write a post

Commenting is the cheapest visibility on the platform and hardly anyone uses it well. A specific, informed reply on a post in your field puts your headline in front of exactly the right people, costs two minutes, and carries none of the pressure to perform. Three good comments a week will do more for a quiet engineer than a monthly post.

• Comment where you genuinely know something, especially where you can correct or extend the point.
• Add a detail the post missed, describe what happened when you tried it, or ask the question the post dodged.
• Skip anything that is only agreement. Great post adds nothing, and everybody can tell.

The only formats worth your time

You do not need opinions about the industry. You need small, true, specific artifacts from your actual work. They are easy to write because you already lived them, and they are the ones that make another engineer stop scrolling.

• The bug: what broke, what you assumed, what it actually was, and what you changed so it cannot recur.
• The decision: two reasonable options, which you picked, and the trade off you accepted.
• The thing you learned this week: three paragraphs, no framing, no lesson for life at the end.
• The build note: what you shipped, one screenshot, and what surprised you.
• The reading note: what a paper, an RFC, or somebody else's codebase changed in how you work.

What the feed rewards, and what it quietly punishes

Distribution follows early substantive replies, so a post that starts a real conversation in its first hour travels further than one collecting reactions. The platform also filters what it reads as low quality content, which is why mechanical growth tactics keep dying. Beyond that, do not model the algorithm. It changes faster than any advice written about it.

• Write so a knowledgeable person has something to reply to. That is the whole mechanic.
• Reply to every comment on your own post for the first hour or two.
• Avoid engagement pods, comment for comment threads, and the artificially spaced one line per paragraph format. Engineers spot it instantly and it costs credibility with precisely the audience you want.
• Do not delete a post because it underperformed. The one person who mattered may have read it.

A cadence that will not take over your life

The failure mode is not posting too little. It is starting at five posts a week, burning out within a month, and concluding that the whole thing does not work. Pick something you could hold for a year while also holding down a full time job.

• Sustainable for most people: one post a fortnight, three comments a week, twenty minutes in total.
• Keep a running notes file. Add a line whenever something at work surprises you, and you will never face a blank box.
• If a fortnight passes and you have nothing true to say, say nothing. Silence costs you far less than filler.

Two hours, once: make yourself findable and believable

This block is where nearly all the return on this page lives. Do it in one sitting with your target job posts open beside you, and refuse to stop and make anything perfect.

• Collect five target job posts and pull out the repeated role nouns and technologies.
• Rewrite the headline using one of the formulas, front loaded with role and stack.
• Write the About section from the five paragraph skeleton, first person, front loaded.
• Add a context line and two real outcomes to each of your last three roles.
• Cut skills to twenty or thirty, pin three, and attach skills to each role.
• Set location to a real metro, claim a clean profile URL, add a photo and a banner.
• Fill in the open to work preference fields and choose your visibility deliberately.

The following week: ask for the three things you cannot write yourself

Everything above is you talking about you. This week is about getting other people into the picture, which takes calendar time rather than effort.

• Request two recommendations using the template, from people who saw specific work.
• Add three items to Featured that a stranger could verify in two minutes.
• Send five personalized messages to engineers at companies you would genuinely join.

Then fifteen minutes a week, indefinitely

The compounding here is unglamorous and it genuinely works. The engineers who never have a painful job search are the ones who kept this loop running while they were employed and happy.

• Update your current role description whenever you ship something you would mention in an interview.
• One substantive comment, and one message with no ask attached.
• Review your headline and open to work settings every quarter, and the week anything changes at work.