---

Introduction to the Problem of Recruitment Without Data Storage

Recently, a discussion erupted in Slack about the best way to match job vacancies and resumes without creating redundant databases. One of the developers raised the question: how can we store only the necessary data while ensuring quality matching? This became a challenge for us, as the effectiveness of our recruitment service depended on it.

Context of the Task

The problem we faced arose as a result of our platform's expansion. Recruiters and candidates began to notice that the search results for job vacancies and resumes did not always align. We understood that our reputation in the market depended on this. If we could not provide quality results, we risked losing the trust of our users, especially in a highly competitive environment.

Specific Difficulties

One example we studied was the matching of resumes where keywords did not always align between vacancies and candidates. For instance, a candidate's resume might contain the term "software development," while the job vacancy required "programming." This discrepancy affected search results and, consequently, user satisfaction. We realized that we needed to find a more flexible and intelligent approach to data processing.

Initial Attempts at a Solution

The first solution we tried was using simple keyword algorithms. We created a system that matched vacancies and resumes based on word frequency. However, this solution proved ineffective. During testing, we noticed that many suitable candidates were not finding job vacancies due to terminology mismatches. This signaled to us the need for a deeper analysis.

Technical Approach to the Solution

Ultimately, we decided to use a more complex machine learning algorithm that considered the context of words and their semantics. We implemented a model trained on a dataset containing various job vacancies and resumes. Here’s an example of code illustrating key implementation points:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

vectorizer = TfidfVectorizer()
vacancy_matrix = vectorizer.fit_transform(vacancies)
candidate_matrix = vectorizer.transform(candidates)

similarity = cosine_similarity(vacancy_matrix, candidate_matrix)

This approach allowed us to match job vacancies and resumes more accurately while minimizing the amount of data we needed to store. We were able to keep only "compressed" representations of vacancies and resumes, significantly reducing the load on our database.

Changes to the Product

After implementing the new algorithm, we noticed a significant improvement in the quality of search results. Candidates began receiving more relevant job offers, and recruiters reported an increase in the quality of matches. This positively impacted the user experience, which, in turn, reflected in the metrics for the /jobs and /for-companies sections. We are confident that these changes will help us strengthen our market position.

Lessons Learned

• Using simple algorithms can lead to insufficient effectiveness.
• Contextual semantics is more important than word frequency.
• Data compression helps reduce storage costs.
• User feedback is a crucial factor for product improvement.
• Don’t hesitate to try different approaches: sometimes the best solution can be unexpected.

Importance for Candidates

Candidates can now expect more accurate and relevant job offers. Thanks to the improved algorithm, their chances of being noticed by recruiters have increased, making the job search process more efficient and enjoyable.

Importance for Recruiters

Recruiters gain access to higher-quality candidates, minimizing the time spent on searches. The enhanced matching system allows them to find suitable resumes more quickly, boosting overall productivity.

Next Steps

Despite the progress made, we continue to monitor the performance of the new algorithm. We plan to conduct further experiments to understand how we can improve matching quality without increasing the amount of stored data. If we had to start over, we would focus more on feedback at the early stages of development to avoid some past mistakes. ---