Automating recruiting, onboarding and offboarding with low-code

We freed the recruiters of a 700-strong company from routine work, set up seamless onboarding and offboarding, and helped raise the share of error-free employee records from 30% to 100%. Here's how we did it.

What things were like before automation

The client is an international online school employing several hundred people. The school always needs new staff across different specialisms, so recruiting there never stops. There are five recruiters in all, each hiring around ten people a month — with the number of interviews and CVs reviewed running into the hundreds.

Before recruiting was automated, an HR specialist would:

• walk every candidate through the entire recruiting funnel themselves,

• bring in the colleagues who needed to take part in onboarding,

• manually fill in all the necessary tables and documents,

• grant access to services, or contact whoever could grant it manually,

• constantly switch between the services they worked with.

Recruiters worked in — and manually entered information into — the following services:

• SignNow — an electronic document-management service,

• Google Workspace — cloud services for organising work and collecting information,

• Slack — the corporate messenger,

• Jira — used as an ATS (Applicant Tracking System); they later moved to Recruitee,

• Job boards such as LinkedIn — aggregators of CVs and vacancies,

• and the work services that new employees were given access to — Intercom, GitLab, Metabase and others.

On top of that, the process was not only un-automated but un-standardised. Recruiters entered information differently, and manually managing absolutely every stage led to a large number of errors.

In the end, only a third of all employees had error-free records — situations frequently arose where someone started work before their contract was signed, after which the process dragged on or never happened at all.

There were onboarding problems too: news of a new person joining the team often reached people who didn't need the information, while everyone who was supposed to work with the new hire found out far from immediately, or by chance. The new employee, in turn, might not understand who their manager was or who to approach with various questions.

Defining the task — which processes need automating

Recruiters used Jira as their ATS and tried to keep track of candidates and documents there. In reality, much of it was done verbally — the work got done, but the ATS wasn't used. As a result, processes weren't tracked and most employee records were incorrect.

We found that staff disliked constantly switching between the task tracker and other services — recruiters spent more than 20 hours a week on administrative work that didn't match their competencies. This took away their ability to do their actual job: sourcing and interviewing candidates.

We needed to set up a seamless recruiting, onboarding and offboarding process — that is, to automate the following:

• processing CVs, sending standard emails and tests, scheduling interviews, and adding information about the results of interactions with a candidate — this saves up to 30% of a recruiter's working time,

• correctly preparing employees' documents, giving them all the access they need when they start, and integrating them into the team — part of onboarding, and the most routine, attention-heavy activity; automating exactly these processes is what raised the share of correctly prepared employee records from 30% to 100%,

• notifying all the relevant colleagues and managers about new people joining the team — this streamlines collaboration between employees.

How the automation was built

The client uses Recruitee as its ATS. On top of it, we built an automated recruiting system that tied together all the services used at the school.

90% of the system was built with no-code development on the basis of the existing Recruitee setup. For the remaining 10% we brought in programmers, since writing code worked out cheaper than the cost of maintaining a no-code solution.

Regardless of the ATS a company uses — whether it's Recruitee, Jira, Trello, Airtable or any other — you can automate the processes with minimal implementation.

We aligned the recruiter's workflow with the automation — processes that used to take a recruiter half a day now run in a couple of clicks:

1. At the data-collection stage, the recruiter can move all of a candidate's CV data from a job board into Recruitee in one click and start working with them.

2. An interview is also scheduled in one click — an email is sent automatically with a personal link to a calendar for booking a call slot. After the meeting, the recruiter manually writes up the results in the Recruitee card.

3. An email inviting a candidate to take a test can be sent in one click. Different positions and departments have different tests, and the automation takes this into account.

4. If a candidate accepts the offer, the recruiter clicks Create Contract and that's it — the contract is ready. The candidate fills in their personal and payment details in the agreement, and the recruiter checks it.

5. Once the contract is signed, onboarding begins.

Collecting candidate data

We launched the first version of the automation a month later — we set up Recruitee and the collection of candidate data into the service from several sources:

• Google Forms,

• a form on the company's website,

• from LinkedIn and other online services via a Google Chrome plugin.

In one click you can send information about a suitable candidate from any service such as LinkedIn or Indeed straight into the ATS. Once the basic functionality was ready, we moved on to refining the system and developing new features.

The selection stage

All information about an applicant is stored in a personal card in Recruitee. A change of status triggers a series of automations:

• sending emails to candidates,

• saving all changes and the interaction history in the applicant's individual thread in Slack,

• notifying the responsible staff — either ordinary informational notifications, or alerts that some process needs overseeing.

If the recruiter is happy with the applicant's experience and qualifications, they move the card to the testing and interview stage, and the applicant receives a link to a test or an invitation to a call.

The interview

The recruiter schedules the interview in the Recruitee calendar, which is similar to Calendly. Each recruiter has their own calendar where they can mark available call slots. When the card's status changes to “Interview”, the automation sends the applicant an email with a link to the calendar, where they can pick a day and time and book their interview slot.

Testing

This stage is automated through an integration of CodeSignal, Slack and an email service.

As soon as the card moves to the testing stage, the automation checks the candidate's position. If tests for that position exist in CodeSignal, the candidate is emailed an invitation to take the test for their role. The test results are saved in the database and sent to the responsible recruiter in Slack — notifications about every interaction with a candidate spare the recruiter from constantly switching between services.

Signing the contract

When the interview and testing stages have been passed successfully, the recruiter adds their feedback on the candidate to the card and moves it to the “Signing the contract” section.

The company has four contract types depending on the department, so the system generates a cooperation agreement from one of four templates, into which the applicant's department and salary information is pulled. The contract is sent to the candidate, and all the recruiter has to do is check that the data is correct.

When the candidate clicks the button in the email, they land in a document form that shows which personal and payment information they need to enter. The main body of the contract can't be changed, and until all the fields are filled in, the contract can't be sent to the recruiter. If the system turns out to be missing information needed for the contract, the recruiter gets a notification that some data is missing. If everything is in order, the notification reports which signing stage the document is at — with status updates arriving in the Slack work chat.

Onboarding an employee after the contract is signed

As soon as an employee signs the contract, a Google Workspace account is created for them and a welcome email is sent with a temporary password for their first login. After the employee logs in, the following information is added automatically:

• department,

• direct manager,

• company start date,

• the recruiter who hired them.

The employee's Google profile is visible to all their colleagues in the company. After this, the system creates access and connects the employee to Slack and other work services according to their department and position. The Slack profile is updated from the employee's Google profile, and editing it manually isn't possible.

The new employee's information is then automatically entered into the payroll table. At the same time, the manager and the new employee's future colleagues receive a Slack notification about when the person is starting and in which role.

If something goes wrong — for example, the user tries to register with an email other than the one they applied with, doesn't receive the welcome email, or any other problem — the system notifies us and/or the recruiter in Slack.

Offboarding an employee

The offboarding process is built like this:

1. The manager fills in a Google Form, specifying the employee's email and the reason for leaving.

2. The recruiter receives a notification and schedules an exit interview to understand the reasons for leaving and try to address them.

3. The recruiter then approves or rejects the termination request — a matter of clicking a thumbs-up or thumbs-down.

4. On the termination date, the system automatically revokes the employee's access to the work services.

Bringing existing employees' records up to standard

Before the automation was introduced, many employees in the company either had incorrect records or weren't formally set up at all. We were asked to:

• check an employee's records — that personal and payment data was current across all documents,

• enter employees into the new system — every process implemented in the company must apply to all employees,

• re-run the setup procedure for any employee whose records contained errors.

To do this, we developed plugins that make it easier to migrate current employees into the new system. We automated the following:

• migrating data from Jira, where it used to be stored, into Recruitee,

• folding the data into the main onboarding process — updating contracts and other documents.

For a recruiter, moving an employee from the old system to the new one is a matter of a few clicks, so the task of bringing documents up to date fits naturally into their working day.

How the client's team learns to work with the system and its updates

Besides mandatory training, employees have a manual that explains in detail what can be done in the system and how. The documentation is updated every few months, once enough changes have accumulated.

We don't abandon our clients and are always in touch if support or further development of the automations is needed. All support requests from the client's staff are sent into our Slack via a bot.

Results

The online school's automated recruiting, onboarding and offboarding system continues to evolve.

A recruiter's job is to find talented people for the company. So we created a comfortable working environment in which they spend almost no time on electronic paperwork or compiling tables and contracts.

Recruiters do the work that matches their core competencies — assessing and interviewing candidates.

Final results:

• recruiters freed up more than 30% of their time to improve the effectiveness of candidate selection,

• the share of correctly prepared employee records rose to 100%,

• managers have access to up-to-date information about the company's staff,

• improved information security — strictly limited access to work services, granted only to current employees.

Automating recruiting, onboarding and offboarding can seem complicated and optional. It isn't — if the automation is done by professional developers with experience in the field, recruiters get a convenient system and quickly get used to it. In return, the company gains saved working time, error-free documents and a transparent way of working with candidates.

Want the same, or need help automating a process in your company? Get in touch!