DEV Community: Miriam Alonso

5 LinkedIn mistakes that filter engineers out before anyone reads the CV

Miriam Alonso — Thu, 20 Aug 2026 13:04:21 +0000

Recruiter search on LinkedIn is a list view. Small photo on the left, name, headline, current company. That's the whole unit of decision for the first pass, and most people never look at their profile in that format.

Five things that go wrong there, roughly in order of how often I see them.

1. The photo only works at full size

Your profile page shows your photo at around 400px. Recruiter search results show it at about 48px, and the messaging sidebar goes smaller than that.

At 48 pixels you have roughly 2,300 to work with. A face fills maybe half. Everything you liked about the photo, the depth of field, the environment, the fact that you're holding a coffee, is gone. What's left is a shape and two or three colours.

The test takes 10 seconds. Zoom out in your image viewer until the photo is the size of a favicon. If you can't tell it's a person facing forward, neither can anyone scrolling a list of 40 candidates.

Tighter crop fixes most of it. Chin to just above the hairline, face filling most of the square. It feels aggressive when you're looking at it full size, which is the point, because nobody is looking at it full size.

2. Your background has the same tone as your hair

This one's specific and it costs more than it should.

At small sizes the only thing separating you from the background is contrast. If you've got dark hair against a dark bookshelf, or light hair against a bright window, the two merge and your head loses its outline. The thumbnail reads as a smudge.

Look at your photo in greyscale. If your head doesn't have a clear edge against what's behind it, the colour version won't fix it. A plain wall a couple of shades away from your hair beats an interesting room, at least at the size where the decision gets made.

If you want a second opinion rather than eyeballing it, there's a free analyser that scores it on contrast, crop and framing. Faster than asking a friend who'll tell you it's fine.

3. Your headline is your job title

Senior Software Engineer at Acme tells a recruiter nothing they didn't already get from the company field two lines down.

LinkedIn indexes the headline heavily for recruiter search. It's 220 characters of prime keyword real estate and most engineers spend 30 of them.

The version that works is boring and specific: the stack, the domain, and what you actually do. Senior backend engineer. Go, Postgres, payments infrastructure. Previously fintech, now healthcare. Someone searching for a Go engineer with payments experience finds that. They don't find Senior Software Engineer.

You don't need to be clever. Clever headlines rank for nothing.

4. Your skills use your vocabulary, not theirs

Recruiters search for the words in the job description they were handed. Those words are frequently not the words you'd use.

You wrote k8s. The req says Kubernetes. You wrote CI/CD. The req says Jenkins. You listed JS and they searched JavaScript.

Neither of you is wrong, and the search still doesn't match. Put both forms in. It looks slightly redundant on the page and it doubles the surface area you're findable on.

Same for job titles. If your company calls you a Member of Technical Staff, nobody is searching for that. Put the industry-standard equivalent somewhere in the profile text.

5. The photo is 3 years and one haircut old

Not a vanity thing. A calibration thing.

If your photo doesn't match what walks into the interview, the first 5 seconds of the call are spent recalibrating instead of listening to you. It's a small tax and it's entirely avoidable.

The reason people don't update is that the alternative feels like a project. Book a photographer, take an afternoon off, spend 200 quid.

It doesn't have to be. Decent LinkedIn headshots come out of a phone camera and 10 minutes near a window, as long as you get the two things above right: tight crop, contrasting background. If you already have a photo you half-like, you can resize and re-crop it rather than starting over. Most photos that "don't work" are just badly cropped.

The order to do these in

If you only do one, do the 48px test. It's free, it takes 10 seconds, and it catches the failure that affects every single impression your profile gets.

Then the headline. That one decides whether you show up in the search at all, which is upstream of everything else on this list.

The rest can wait for a rainy Sunday.

Disclosure: I work on BetterPic, one of the tools linked above.

Background removal without a green screen is an underdetermined problem. Here's what the maths is doing.

Miriam Alonso — Thu, 20 Aug 2026 13:04:02 +0000

Every pixel in a photograph of a person against a wall is a blend of two things. The compositing equation is the whole problem in one line:

C = αF + (1 - α)B

C is the pixel you can see. F is the foreground colour, B is the background colour, and α is how much of that pixel belongs to the foreground. Solid shirt, α is 1. Empty wall, α is 0. A single strand of hair crossing that pixel, α is 0.3 and the pixel is genuinely part person, part wall.

Now count the unknowns. F is 3 numbers, B is 3 numbers, α is 1. That's 7. And you know 3, the RGB of C.

Seven unknowns, three equations. The problem is underdetermined and no amount of cleverness makes it not underdetermined. Everything that follows is about finding constraints from somewhere else.

What a green screen actually buys you

It gives you B.

If you know the background is (0, 177, 64) everywhere, you've eliminated 3 unknowns and the system becomes solvable per pixel. That's chroma keying, and it's why it's been in use since the 1930s. It turns an ill-posed inverse problem into a colour distance test:

distance = np.linalg.norm(pixel - key_colour, axis=-1)
alpha = np.clip((distance - tolerance) / softness, 0, 1)

That's the core of it. Everything else in a keyer is refinement around the edges.

The reason nobody shoots headshots on green is that the green bounces. Light hits the screen, reflects, and lands on the side of your subject's face and hair. Now your foreground colour F is contaminated by the thing you're trying to remove, and you need spill suppression, which is its own pile of heuristics.

Without a green screen, you get two families of approach

Segmentation. Train a network to output a mask directly. U²-Net and IS-Net are the ones most background removal tools are built on, and they're doing binary-ish classification: person or not person, per pixel.

This is fast, runs in a browser via ONNX, and handles the 95% of the image that's obviously shirt or obviously wall. It falls apart on exactly the pixels where α is between 0 and 1, because the model is being asked for a yes or no on a pixel where the honest answer is 0.3.

That's why cheap background removal gives you either a jagged cut-out edge or a soft halo of the old background. The model picked, and picking was the wrong operation.

Alpha matting. Split the image into three regions first: definitely foreground, definitely background, and an unknown band around the boundary. That's a trimap. Then solve for α only inside the unknown band, using the known regions as colour samples to constrain the equation.

Closed-form matting does this by assuming F and B are locally smooth, which turns the whole thing into a sparse linear system you can actually solve. Deep matting approaches learn the same thing end to end.

Matting is where the quality lives, and it's slower by an order of magnitude, which is why not everything uses it.

Hair is the whole difficulty

I want to be precise about why, because "hair is hard" gets said a lot without the mechanism.

A human hair is about 70 micrometres across. Photographed at portrait distance on a phone, that's well under one pixel wide. So a pixel containing hair contains hair and whatever is behind it, permanently mixed at capture time. The information about where one ends and the other begins was destroyed by the sensor.

You cannot recover it. You can only make a plausible guess, and the guess is constrained by the colours around it.

Which leads to a rule that's genuinely useful when you're taking the photo: the recoverability of your hair edge depends on the contrast between your hair and the wall. Dark hair against a dark bookshelf is unrecoverable, because the mixed pixel and the pure background pixel are the same colour and no algorithm can tell them apart. Dark hair against a light grey wall separates cleanly.

That's not a limitation of the tool. It's information theory. The tool cannot invent a distinction that isn't in the file.

The second failure: colour spill survives a correct alpha

Say you nailed α. You composite onto a new background:

C_new = αF + (1 - α)B_new

And it still looks wrong. There's a faint fringe of the old wall around the shoulders and through the hair.

That's because F itself was contaminated. Light from the old background bounced onto your subject. The semi-transparent pixels carry a colour cast that has nothing to do with the new scene, and mathematically your α was fine.

Spill suppression is a separate pass, and most automatic tools either skip it or apply something crude like desaturating the boundary band. Which is why swapped backgrounds so often have a grey rim that reads as "cut out" even when you can't name what's wrong.

What this means if you're taking the photo

Everything above collapses into four shooting decisions.

Stand a metre or more off the wall. Less bounce onto you, less spill in F, and the background goes slightly out of focus which helps segmentation.
Pick a wall that contrasts with your hair, not your shirt. Hair is where the algorithm needs the signal.
Avoid backlight. A window behind you puts a bright rim through your hair, which is beautiful and which destroys the hair edge for matting, because now the hair pixels are the same brightness as the background.
Plain beats interesting. A busy background gives the segmentation model more edges to confuse with your outline.

Do those and even a mediocre segmentation model gives you a clean result. Skip them and the best matting implementation in the world is working with a file that doesn't contain the answer.

Doing it in practice

If you just want to swap the backdrop on a photo you already have, the background options that come out of a matting pipeline look very different from the ones that come out of a plain segmentation mask, and it's usually obvious at the hair line which you're looking at. Zoom in on the edge before you commit to anything.

For the crop and the export you can do it in a browser without installing anything, and if the source photo is the problem rather than the background, BetterPic generates from selfies instead, which sidesteps the matting question entirely because the background was never real to begin with.

The takeaway that isn't obvious

Background removal quality is decided at capture, not in post. The algorithm can only redistribute information that's already in the file, and the mixed pixels at the hair boundary either contain a recoverable distinction or they don't.

One metre off the wall and a background that contrasts with your hair. That's most of it.

Disclosure: I work on BetterPic, one of the tools linked above.

How AI headshot generators actually work: LoRA, 15 selfies, and the overfitting problem

Miriam Alonso — Thu, 20 Aug 2026 13:04:01 +0000

Every AI headshot product works roughly the same way under the hood, and once you know the shape of it, most of the weird results stop being weird.

You upload 10 to 20 selfies. Twenty minutes later you get 100 portraits back. Some look exactly like you. Some look like your cousin. One looks like you wearing a jacket you've never owned, in an office you've never been to, and that one is usually the most interesting failure.

Here's what's happening in between.

The pipeline has four stages

Face detection and crop. Your uploads get run through a face detector, cropped square, aligned so the eyes sit on roughly the same horizontal line, and resized. Anything where the detector fails, or finds two faces, gets dropped.
Captioning. Each image gets a text caption, usually auto-generated, containing a rare trigger token. Something like sks person, wearing a blue shirt, indoor lighting.
Fine-tuning. A small adapter is trained on top of a frozen base model so the trigger token means your face.
Generation. The adapter gets loaded, and the product runs its own prompt library against it. sks person, corporate headshot, grey backdrop, softbox lighting, a few hundred times with different seeds.

Stage 3 is where all the quality lives, so that's the one worth understanding.

LoRA in one paragraph that isn't hand-wavy

A diffusion model has a few billion parameters. Fine-tuning all of them for one person's face would take hours on serious hardware and produce a multi-gigabyte file per customer. Nobody's running a business on that.

LoRA, Low-Rank Adaptation, sidesteps it. Instead of updating a big weight matrix W, you freeze W and learn two skinny matrices A and B whose product has the same shape. At inference you compute W + BA. If W is 1024x1024 and you pick rank 16, then A is 16x1024 and B is 1024x16. That's 32,768 trained numbers instead of 1,048,576, so about 3%.

These adapters get injected into the attention layers, which is where the model decides what a thing looks like rather than where it goes. Train for a few hundred steps, ship a file that's a few megabytes, load it in milliseconds.

The rank is the knob. Low rank, say 4 to 8, and the adapter doesn't have enough capacity to hold your specific face, so you get a generic person who vaguely resembles you. High rank, 64 and up, and it has enough capacity to memorise your training set wholesale, which sounds good and isn't.

Why 15 photos and not 500

This surprises people. More data is supposed to be better.

The problem is that the adapter learns everything your photos have in common, and it has no way to know which of those things you consider "your face".

Upload 15 selfies taken in the same week and 12 of them will have the same haircut, the same lighting from the same window, and the same three t-shirts. The model learns sks person means a face plus that lighting plus those shirts. Then you ask for a corporate headshot and it fights itself, because half of what it learned about you is a grey marl t-shirt in a bedroom.

That's overfitting, and on faces it shows up in a specific way: the generated images look great and they all look like the same photo. Same angle, same expression, same background tone. The model isn't generating your face in new situations. It's reconstructing your training set with slight variation.

Fifteen genuinely different photos beat 100 near-duplicates, every time. Different days, different rooms, different clothes, a couple of different angles.

The failure everyone hits: identity drift

The opposite failure is more common in the cheap tools. You get 100 clean, well-lit, professional portraits of somebody who is nearly you.

Two things usually cause it.

Undertrained adapter. The trigger token never fully bound to your face, so the base model's idea of "a person" is doing most of the work. You get a composite of you and the average face in the model's training data.

Prior preservation pulling too hard. To stop the adapter from destroying the model's general concept of "person", training usually mixes in generated images of random people alongside yours. Too much of that and your identity gets regularised away.

There's a measurable version of this. Take a face embedding model, generate an embedding for your input photos and for each output, and compute cosine similarity. Anything above about 0.65 reads as clearly the same person. Below 0.5 and most people looking at it will say "that's not quite you", even if they can't say why.

If a product isn't filtering its outputs on something like that score, you're doing the filtering by hand, which is what it feels like when you get 100 images back and 12 are usable.

What this changes about the photos you upload

The practical version, given all of the above:

Vary the background more than the pose. The background is the thing most likely to get baked into your identity, because it occupies the most pixels.
Include at least 3 different tops. Clothing is the second thing that gets baked in.
One or two photos where you're not smiling. If every input is a grin, every output is a grin, and it will look like the same grin.
Skip anything with a second face in it, even blurred in the background. Detectors get confused and the crop goes wrong.
Skip heavy filters. Instagram-style colour grading gets learned as part of your face.

Roughly 15 photos, ideally from more than one occasion. The person who takes 15 selfies in one sitting in one room gets noticeably worse results than the person who digs 15 out of their camera roll from the last year.

Trying it without paying for it

If you want to see what the pipeline does with your photos before committing, most of the products have a free tier that runs a smaller version. You can put a handful of selfies through a free generator and see the identity-drift problem for yourself, which is a faster education than reading about it.

The paid versions of AI headshots mostly differ in how much they spend on stage 4, the generation and filtering, rather than on anything exotic in stage 3. Everyone's doing LoRA or something close to it. The difference is how many candidates get generated and how aggressively the bad ones are thrown away before you see them.

Which is also why the outputs vary so much between products at the same price. If you want to see the difference in practice, it's worth looking at BetterPic side by side with Aragon rather than trusting anyone's sample gallery, including ours. Sample galleries are cherry-picked by definition.

The one thing worth remembering

The model has no concept of "your face" as separate from "the pixels in your uploads". Everything consistent across your training images becomes part of your identity as far as the adapter is concerned.

So the quality of your result is decided almost entirely before you hit upload.

Disclosure: I work on BetterPic, one of the tools linked above.

I probed GitHub's avatar CDN. Your 4000px profile picture is 3KB by the time anyone sees it.

Miriam Alonso — Thu, 20 Aug 2026 13:03:40 +0000

GitHub serves every avatar through avatars.githubusercontent.com with a size parameter stuck on the end. You've seen these URLs if you've ever opened devtools on a PR page:

https://avatars.githubusercontent.com/u/1?s=40&v=4

I was curious what s actually does, so I pulled the same avatar at seven different values and measured the bytes that came back.

s=40      3,144 bytes
s=80     10,710 bytes
s=128    25,298 bytes
s=260    94,255 bytes
s=400   215,383 bytes
s=460   282,530 bytes
s=1000  282,530 bytes

Two things fall out of that.

460 is the ceiling. Ask for 1000 and you get the 460 file back, byte for byte. GitHub stores your avatar at 460x460 and throws away everything above it, whatever you uploaded.

Then look at the top row again. The avatar next to your name on every issue comment, every review, every commit in the timeline, is 3,144 bytes. That's 1.1% of the file GitHub is holding for you.

Nobody sees your profile page

Think about where your face actually appears on GitHub.

Your profile page renders it at 260px. That page gets visited when someone is deliberately looking you up, which is rare.

Everywhere else it's 40px. Comment threads, review requests, the contributors list, the commit history. 40 pixels, on a screen, next to a username.

So the picture you agonised over is being judged at roughly the size of this: ●

At 40px you have about 1,600 pixels to work with. A face fills maybe half of that. You're not communicating an expression at that resolution. You're communicating a shape and two or three colours.

The bit that surprised me

I assumed the small sizes were just the big file scaled down in the browser. They're not. GitHub is generating and caching a separate encode at each size, and the compression at 40px is aggressive enough that fine detail is gone before it reaches the client.

Which means the usual advice, upload the highest resolution you have, is only half right. Resolution above 460 does nothing on GitHub. What matters is whether the image still reads when a JPEG encoder has 3KB to describe it.

Two things survive that budget: contrast between the subject and the background, and how much of the frame the face occupies. Everything else, the texture in your jumper, the bookshelf behind you, the lanyard, turns into mush.

Every platform disagrees with every other platform

This is where it gets annoying if you keep one photo across your accounts.

Platform	Stored	Rendered small	File cap
GitHub	460x460	40px in threads	1MB
LinkedIn	up to 7680px wide	~48px in feed	8MB
Slack	512 to 1024	24px in message list	1MB
Discord	512 recommended	128px, often 32px in member list	8MB

I've checked GitHub myself. The others come from each platform's own documentation, so treat them as roughly right rather than gospel, and note that Slack's 1MB cap is a lot tighter than people expect.

The practical version: export one square at 512x512, keep it under 1MB, and every platform in that table will take it and scale down cleanly. 512 divides evenly into 256, 128, 64 and 32, which means fewer resampling artefacts on the small renders than you'd get from, say, 460 or 400.

If you want to check the crop at several sizes before you commit, a free profile picture editor will do the square crop and the export without opening anything heavier.

What this changes about the photo itself

I went back through my own avatars with the 40px test in mind and the pattern was pretty clear.

The ones that worked had the face taking up most of the frame and a background that was one flat tone away from my skin and hair. The ones that didn't were technically better photographs. Nice depth of field, interesting environment, more of my shoulders in shot. At 40px they read as a grey smudge.

So the checklist is short:

Crop tighter than feels right. Chin to just above the hairline.
Pick a background that contrasts with your hair, not with your shirt.
Look at it at 40px before you upload. Zoom out in your image viewer until it's the size of a favicon. If you can't tell it's you, nobody else can either.
Skip the sunglasses, the hat brim shadow, and the busy patterned shirt. All three vanish or turn to noise.

Step 3 is the one people skip and it's the only one that actually tests anything.

If you don't have a usable photo

Plenty of us don't. I went about four years with a photo my flatmate took in a kitchen because the alternative was booking a studio.

The generated options have got good enough to be worth a look. You can run a free AI headshot generator on a handful of selfies and see what comes out before paying for anything.

One thing that carries over from the 40px problem: the prompt controls framing and background separation, which are exactly the two variables that decide whether the result survives being shrunk. Tight crop and flat background beat cinematic lighting every time at this size. There's a decent breakdown of prompt patterns that survive a diffusion model if you want to skip the trial and error.

Try it on your own

for s in 40 80 128 260 460 1000; do
  echo -n "s=$s  "
  curl -sL "https://avatars.githubusercontent.com/u/YOUR_ID?s=$s&v=4" \
    -o /dev/null -w '%{size_download} bytes\n'
done

Swap YOUR_ID for your numeric GitHub user ID, which you can get from https://api.github.com/users/YOUR_USERNAME.

If your 460 number is close to 1MB you're near GitHub's upload cap and the smaller encodes are working harder than they need to. Re-export at 512 and it'll come down a lot.

Disclosure: I work on BetterPic, one of the tools linked above.