Maintaining Anonymity in Interview Feedback

Most interview review sites operate on a clumsy trade. You get transparency, but only if you're willing to gamble your privacy or hope the site's "anonymous" tag actually holds up. It's a leaky system. We decided to build something that doesn't rely on trust or a promise to keep secrets.

Our platform simply doesn't ask for names. We don't collect them, and we don't publish them. By removing the identity layer entirely, we've cut out the risk of accidental doxing or revenge posts. It's a boringly simple solution to a problem that most sites try to solve with complex terms of service that nobody reads.

The real value isn't just in the reviews, though. We've added a public record for ghosting. It's a way to track companies that go silent after the final round, turning a private frustration into a visible data point.

Is a public shame list enough to make recruiters actually hit "send" on an email? We're about to find out.

The problem with named feedback

Named feedback is a disaster for data quality because it forces people to lie. When a candidate's name is attached to a review, they stop being honest and start being "safe." They won't tell you the interviewer was condescending or that the technical test was irrelevant because they're afraid of burning a bridge in a small industry. It's a survival instinct that renders the feedback useless for anyone actually trying to fix a hiring process.

The risk isn't just about missed jobs; it's about retaliation. If a candidate reports that an interviewer was unprofessional, that interviewer can easily find the candidate on LinkedIn and leave a spiteful comment or flag them to other recruiters. It's a power imbalance that makes transparency a liability.

The same problem applies to the interviewers. Public shaming is a real risk when a candidate is frustrated. I've seen cases where a candidate leaves a scathing, named review because they didn't get the job, turning a professional critique into a personal vendetta. This part is genuinely confusing for companies that think "accountability" requires names. In reality, accountability requires honest data, and names kill honesty.

If you're building a feedback system, you need to decouple the identity from the response. A simple hashing mechanism lets you track a candidate's journey across multiple interviews without ever storing their plaintext name in the feedback table.

import hashlib

def anonymize_user(user_email, salt="company_secret_2024"):
    # Combine email with a salt to prevent rainbow table attacks
    combined = f"{user_email}{salt}".encode('utf-8')
    return hashlib.sha256(combined).hexdigest()

print(anonymize_user("candidate@email.com"))

Maintaining data integrity without identities

We verify review authenticity by using cryptographic hashes of a candidate's application ID and the company's unique identifier. This creates a unique fingerprint for the interaction without storing a name or email in the review record. If a user tries to post five reviews for the same company, the system sees five identical hashes and flags them as duplicates.

The logic is simple: we care that the event happened, not who specifically did it. This part is genuinely confusing because most people assume you need a user account to prevent spam. You don't. You just need a consistent piece of data from the application process that you can hash.

import hashlib

def generate_review_hash(app_id, company_id):
    # Combine IDs and hash them to verify authenticity anonymously
    combined = f"{app_id}:{company_id}".encode()
    return hashlib.sha256(combined).hexdigest()

print(generate_review_hash("app_12345", "comp_678"))

To keep the feedback actionable, we categorize the "failure point" of the interview process. A report stating "the interviewer did not show up for the Zoom call" is useful because it identifies a process breakdown, regardless of who the candidate is. We strip the identity but keep the metadata, such as:

• The specific interview stage (e.g., Technical Screen)
• The date of the interaction
• The reported outcome (e.g., No-show)
• The company size bracket

Anonymity by omission

Stripping names from the process is a decent attempt to reduce bias, but I think it underestimates the friction of actual hiring. Most managers won't hire a stranger based on a nameless profile; they'll just find a way to deanonymize the candidate through a LinkedIn search or a Google query. If the goal is truly blind hiring, you have to strip the pedigree and the specific company names too. Otherwise, you're just hiding the name while leaving the "where they worked" signals intact.

The community reaction is mostly noise about the general misery of the job market, but the complaints about "vibe-coded" design are a fair critique. When you remove identifying data, the aesthetic of the platform becomes the primary signal. If the UI feels amateur or overly curated, users stop trusting the data behind it. People are already on edge because of the surge in fraudulent job ads; a lack of transparency in naming can easily be mistaken for a lack of legitimacy.

I'm not convinced this solves the ghosting problem people are venting about. Anonymity might make it easier to apply, but it doesn't force a company to respond. I wonder if this actually makes it easier for recruiters to ignore candidates because there's no human face attached to the application.

Conclusion

We aren't trying to build a complex encryption layer or a secret society. We just don't ask for names. By omitting the identity of both the candidate and the interviewer from the start, the anonymity is baked into the data structure rather than being a feature we have to maintain.

It's a blunt solution, but it works. Whether this is enough to actually shift how companies handle ghosting—or if it just becomes another place for people to vent—remains to be seen. For now, the "No approved reports yet" on the leaderboards is the most honest metric we have.