Looking for a smarter way to organize your candidates and actually reach out to the right people, not just everyone in your database? If you’re tired of “spray and pray” recruitment, this guide is for you. We’ll cut through the fluff and show you—step by step—how to use tags in Loxoapp to segment your talent pool and run targeted outreach that actually works.
Whether you’re a recruiter juggling 300+ candidates or a sourcer who wants to avoid doubling up on emails, this is the real-world approach to tags you wish someone had told you sooner.
Why Segmentation Matters (and Tags Actually Help)
Let’s be honest: Most candidate databases turn into a noisy mess fast. You end up with folks from last year’s project, people you’ve already placed, and ten versions of “Java Developer” from every corner of the world. If you’re not segmenting, you’re sending the same generic messages to everyone—and your response rates tank.
Tags aren’t sexy, but they work. They’re like sticky notes on your candidates: quick, flexible, and way less rigid than fiddling with custom fields or endless lists. Used right, tags let you:
- Group candidates by skill, location, or status.
- Filter out the folks who aren’t relevant right now.
- Run targeted campaigns instead of mass blasts.
- Avoid embarrassing mistakes (like contacting someone you already hired).
But don’t get carried away—tag bloat is real. More on that soon.
Step 1: Decide What You Actually Want to Segment
Before you tag a single candidate, pause. Seriously. If you just start making up tags on the fly, you’ll end up with a mess—“Java,” “java,” “Java Dev,” and “JAVASCRIPT??”—and no one will know which one to use.
Start with the end in mind: - What kinds of outreach will you do? (Skill-based, location-based, past applicants, etc.) - What info do you actually need to filter on? - Who else is using your database? (Consistency matters.)
Common, useful tag categories: - Skill sets (“python”, “salesforce”, “aws”) - Seniority (“junior”, “senior”, “lead”) - Location (“nyc”, “remote”, “london”) - Stage in pipeline (“screened”, “client submitted”, “do not contact”) - Source or campaign (“linkedin sourced”, “referral”, “campus 2024”) - Past engagement (“replied”, “interviewed before”, “no show”)
What to ignore: - Super granular tags you’ll never use again (“spoke-to-monday-morning”) - Duplicates (“java dev” and “java developer”) - Anything that’s better as a field (like salary expectations)
Pro tip: Write down your core tags on a sticky note before you start. If you need to reference a spreadsheet to remember all your tags, you’ve made it too complicated.
Step 2: Set Up a Tagging System Everyone Can Follow
Tags are only useful if you (and your team) use them the same way. Otherwise, it’s chaos. Here’s how to avoid that:
Keep it lowercase and simple. - Pick a naming style (“backend” not “Back-End” or “Back End”). - Avoid punctuation and weird abbreviations.
Decide on tag “families.” - For skills, always tag the main skill (“python”), not just the job title. - For locations, use standard city or region names (“chicago” not “chi-town”). - For status, agree on a small set of pipeline stages (“screened”, “client submitted”).
Document it somewhere. - Even a Google Doc beats relying on memory. - Make sure new recruiters know what tags to use (and which to avoid).
Don’t be afraid to clean up. - If you spot duplicates or misspellings, merge or delete them. - Limit yourself to tags you actually search/filter by.
What doesn’t work? - Letting everyone make up their own tags. You’ll end up with “nyc”, “NYC”, and “new york city”—all meaning the same thing, but none catching everyone you want.
Step 3: Tag Candidates as You Go (and Don’t Overthink It)
If you wait until you have 1,000 untagged candidates, you’ll never catch up. Make tagging part of your daily workflow:
- When you add a new candidate, tag them right away.
- After a call or interview, update their tags if something new pops up.
- When you’re bulk importing, set aside a few minutes to tag by group.
How many tags per candidate? - Enough to find them again, not so many you can’t remember what matters. - Usually 2-5 is plenty (e.g., “python”, “remote”, “screened”).
Avoid these mistakes: - Tagging someone with everything “just in case.” That’s how you end up with “maybe interested” on half your database. - Creating a new tag for every tiny difference. If you’re the only one who’ll ever use it, skip it.
Pro tip: If you have a batch of similar candidates (say, from a bootcamp), tag them all at once. Loxoapp lets you bulk-edit tags—use it.
Step 4: Use Tags to Build Smart Lists for Outreach
Here’s where tags start to pay off. Instead of blasting everyone, you can filter and build lists that make sense for your role or campaign:
- Looking for “senior” “python” devs in “nyc”? Just filter those tags.
- Want to re-engage people who haven’t replied? Filter out “replied” and “do not contact.”
- Running a campaign for remote roles? Tag candidates with “remote” and target just them.
How to actually do it in Loxoapp: - Use the filter/search bar in your candidate database. - Select multiple tags to narrow down your list. - Save filtered lists for future use (e.g., “2024 Java Remote Pool”).
When NOT to use tags: - To store data that belongs in a field (like email status or salary). - To track one-off notes (“left voicemail 2/7”—that belongs in activity notes).
Pro tip: Don’t forget to remove or update tags as people’s status changes. Otherwise, you’ll be inviting people to jobs they already turned down.
Step 5: Run Targeted Outreach That Doesn’t Get Ignored
Now that you’ve got clean, segmented lists, your outreach can finally be more personal—and less likely to get marked as spam.
- Use tags to send tailored messages (“Hey, Python devs in NYC…”).
- Avoid embarrassing errors (don’t invite “do not contact” folks).
- Track which tags respond best over time—then double down.
What works: - Short, relevant messages to a focused group. - Personalization that goes beyond just “Hi, {First Name}.”
What doesn’t: - Mass emails to everyone with a pulse. - Ignoring your tags and “just searching” every time.
Pro tip: Review your outreach stats regularly. If a tag group never responds, maybe your segmentation is off—or those candidates just aren’t interested.
Step 6: Keep It Clean (and Don’t Be Afraid to Prune)
A tagging system is like a garden: ignore it, and it’ll get overgrown. Set a reminder to review your tags every quarter (or whenever things feel messy):
- Merge duplicate tags.
- Delete ones no one uses.
- Standardize misspellings.
- Remove outdated tags from candidates who’ve moved on.
What to ignore: Don’t obsess over perfect taxonomy. The goal is to find candidates fast, not win an award for neatest database.
Honest Takes: What Works, What Doesn’t, and What to Skip
What works: - Consistent, simple tags that everyone understands. - Using tags for things you actually filter by. - Bulk tagging and regular cleanup.
What doesn’t: - Overcomplicating things with 50+ tag types. - Using tags as a dumping ground for every bit of info. - Letting the system get stale and never reviewing it.
What to ignore: - Fancy color-coding or emojis in tags (it’s not Slack). - Tags for data you’ll never use. - Overly specific tags that only make sense to you.
Keep It Simple and Iterate
A good tagging system in Loxoapp isn’t about perfection—it’s about making your life easier and your outreach smarter. Stick to tags that mean something, keep them consistent, and don’t be afraid to tidy up as you go. If you’re not sure where to start, pick three or four tag categories and build from there. You’ll be amazed how much more effective (and less stressful) your recruiting gets when you can actually find the right people, fast.