How Fibery Handles Hiring

The Hiring Space in Fibery is built to manage the entire recruitment lifecycle, from job postings to final hiring decisions. Let’s see how it works.

We don’t have a dedicated HR department, so the hiring manager is always the person who will actually work with the new teammate. Vacancies are posted across several platforms, and every application is reviewed manually without delegating this responsibility to AI (although it looks like it makes sense, looking at the quality of some applications…). Our goal is to respond to every candidate, whether they’re a match or not, and to keep a complete, transparent record of all interactions. To make this smoother and less error-prone, we decided to polish our workflow in Fibery so that all stages of the process — from collecting applications to scheduling interviews and tracking communications — are neatly structured, easy to follow, and leave no candidate overlooked.

You are welcome to install the template right away here. Please note that you will need to connect the email integration yourself and also replicate the integration-related formulas manually.

Typical workflow: from Job Opening to Hire

1. Create Position → Add a new position and assign a hiring manager.
2. Candidates Apply → Either added manually (rare) or submitted via a form (most cases).
3. Initial Screening → A responsible team member reviews the candidate and moves them to either “Followed up” or “Not Hired”.
4. Interview Process

• Move promising candidates to “To interview”
• Schedule and document interviews
• Record outcomes in the Interview database
• Continue progress through stages like “Interview passed” and “Offer made”

5. Decision Phase → Final state is set: Hired, Not hired, or Declined.
6. Close Position

What have we done to make it easier to process?

Collecting candidates — How we made it sane

In the early days, we asked candidates to apply via email to a shared inbox new@fibery.io. That turned out to be a mess. The inbox was flooded with all kinds of messages — newsletters, product feedback, spam — making it nearly impossible to spot and track actual job applicants. Candidates were easily overlooked, and the hiring process became chaotic and unreliable.

To fix this, we started using Fibery form as the single source of truth for all incoming applications. This form includes all the relevant fields we need — name, CV, LinkedIn, role, background, and more — and every submission goes directly into the Hiring/Candidate database.

By doing this:
✅ No candidates are lost or forgotten
✅ All data arrives structured and complete
✅ Everyone involved in hiring sees the same up-to-date list

Integrated with Email

To streamline candidate communication and make the process more transparent, we’ve integrated email syncing directly into Fibery. Once configured, all email exchanges with candidates are automatically pulled in and linked to the correct Candidate record — based on their email address.

This integration brings a few powerful benefits:

• Automatic Linking: Emails are matched to candidates without manual effort
• Conversation History: When you open a Candidate, you instantly see all email exchanges — perfect for curious teammates who want to stay in the loop
• Smart Metrics via Formulas: We also use email data to drive meaningful insights:
  • Days to First Reply: ToDays(Emails.Filter(Right(Email, 10) = “@fibery.io”).Min(Date) - [Creation Date]) → Measures how quickly we respond to applications
  • Total Email Count: Emails.Count() → Tracks all communication volume
  • Emails Till Decision: Emails.Filter(Right(Email, 10) = “@fibery.io” and (IsEmpty([Decision Date]) or [Decision Date] > Date)).Count() → Shows how many emails were exchanged before the hiring decision
  • Latest Communication Date: Emails.Max(Date) → Lets us see when the last contact was

Rejecting Candidates 😢

Like most teams, we received a large volume of applications, and while every candidate was reviewed by a real human (the hiring manager!), it became clear that rejecting non-fit applicants manually was time-consuming.

To streamline this part of the process without sacrificing empathy or professionalism, we introduced simple automation with clear intent — a set of rejection buttons that cover the most common scenarios:

1. Reject → Sends a polite, default rejection email automatically.
   Ideal for cases where the candidate is clearly not a fit, but you still want to acknowledge the effort and bring closure.
2. Reject with Custom Message → Opens an email draft where you can explain why it’s not a match and offer a more personal note — for candidates who showed potential or made a thoughtful application.
   Great for keeping the door open for future opportunities.
3. Reject Silently → No email is sent. Used for clear misses (e.g., applicants who didn’t read the role description or totally mismatch the requirements).
   Helps avoid unnecessary back-and-forth while still logging the decision internally. It’s also easy to see, why candidate was rejected.

   

Follow-up

For candidates who look promising but need more info or scheduling, we wanted to make follow-ups smooth, personalized, and fast — without the hassle of switching tools.

So we built a “Follow-Up” automation button> directly into Fibery.

When clicked, it:

• Prepares a draft with the candidate’s email and your sender info
• Auto-generates a subject line using a formula
• Lets you write a custom message right inside Fibery
• And finally — sends the email in one click

Reporting

Because everything lives inside Fibery — from candidate details to emails and decisions — we get powerful reporting almost for free.

With just a few views, charts, and formulas, we can:

• See how many candidates applied and how they’re distributed across hiring stages
• Discover where the best candidates come from (geographically or by channel)
• Track conversion rates between stages (e.g., New → Interview → Hired)
• Measure time-to-hire, email response times, and drop-off patterns

Smart agent help

One of the coolest parts of our setup is the Smart Agent in Fibery. You can ask it questions like:
“How many emails have I sent to candidates since last Monday?”
… and it will figure out the filters, interpret time frames, and query your database accurately.

It understands not only date ranges and logic, but also context across related fields like Candidate, Sender, or Email Date. Even when it needs clarification — like in the screenshot — it will ask the right follow-up to avoid errors.

Once clarified, it can:

• 🕵️ Filter out just your emails
• 🧩 Count only those linked to candidates
• 📅 Use smart date handling (e.g. “last Monday” → exact date)
• 🧠 Summarize patterns and detect content uniqueness (like in the 51 unique email content types case)

It’s a massive time-saver. Especially if you are simply curious and have volumes of data. You don’t need to create filtered views or build reports manually. Just ask in natural language and get precise answers in seconds.

Data structure

If you are curious about how it was built, you can install the template here, or build the structure on your own.

The hiring setup in Fibery is built around three tightly connected databases — Positions, Candidates, and Interviews — to mirror the real-life flow of recruitment.

• The Position database tracks job openings, which can be marked as “Open” or “Closed,” assigns a hiring manager from the Fibery team, and automatically aggregates candidate metrics such as total, active, and unprocessed applications. It also links job postings to related blog articles and, when someone is hired, connects directly to the employee’s record in the company database.
• The Candidate database holds all applicant details and moves them through an eight-stage workflow — from “New” to “Hired,” “Not hired,” or “Declined” — while recording communication metrics like email count, days to first reply, and last contact date, all powered by email integration. Candidate records store essential details (CV, LinkedIn, location, phone) from the application form and allow quick replies via rejection buttons.
• The Interview database manages interview scheduling, notes, results, and recordings, with the ability to assign multiple team members. Relationships between the databases ensure that each position lists all its candidates and each candidate’s interview history, keeping the hiring process both structured and traceable.

Have any ideas on how to make it better? You are welcome share that (as always!)