Recruiting workflows get harder to manage as hiring scales. Spreadsheets stop working once you’re tracking dozens of candidates across multiple roles and pipeline stages.

Traditional Applicant Tracking Systems (ATS) solve part of this. They are expensive, hard to customise, and disconnected from internal tooling. That gap is where an AI-assisted ATS comes in.

An AI-assisted ATS is a system that uses large language models (LLMs) to score candidates, match them against job descriptions, parse resumes, and surface strengths and gaps automatically. Recruiters spend less time reading and more time interviewing. Think of it as an AI resume parser combined with a candidate evaluator and a recruiter dashboard, stitched together as a single internal tool.

In this tutorial, you’ll build one using:

• OpenAI for candidate evaluation
• ToolJet DB for storing data
• ToolJet for the recruiter dashboard
• Structured prompts for reliable outputs
• Low-code workflows for hiring automation

A working AI-powered ATS that:

• Stores applicants and open jobs
• Triggers AI evaluation on demand
• Returns score, match, and summary
• Displays strengths and gaps clearly
• Surfaces AI insights instantly in-app

Fig 1: Applicant Tracking System

The same low-code architecture works for HR-tech MVPs, internal recruiting platforms, candidate-ranking dashboards, and any operational tool that needs an AI hiring automation layer plugged into existing data.

An Applicant Tracking System manages hiring workflows: candidate records, job pipelines, application status, and recruiter notes.

An AI-assisted ATS adds a layer of large-language-model automation on top. Instead of manually reading every application, recruiters get:

• Automated candidate scoring against requirements
• Job-fit matching as percentages
• AI-generated recruiter summary text
• Strengths and gaps analysis
• Faster shortlisting and pipeline triage

The goal isn’t to replace recruiters. It removes the repetitive evaluation work so recruiters can focus on conversations, calibration, and closing candidates instead of skim-reading hundreds of profiles.

Building recruiting software from scratch usually means engineering effort across:

• Frontend dashboards and design systems
• Backend APIs with auth
• Database schemas and migrations
• Workflow automation and triggers
• AI integration and prompt management

ToolJet handles most of this through low-code building blocks. You drag in tables, modals, and buttons. Queries connect them to ToolJet DB or external APIs like OpenAI. The whole thing runs on the ToolJet runtime with no separate Next.js project, no separate backend, and no hand-rolled auth.

For an ATS specifically, the value compounds:

• Recruiter dashboards are CRUD interfaces
• ToolJet DB removes external database setup
• AI workflows plug in as queries
• Role-based access controls ship in-platform
• Self-hosting supports compliance-sensitive teams

This makes ToolJet a strong fit as a low-code ATS platform for HR-tech MVPs, internal recruiting platforms, and any team that needs a working demo in hours instead of weeks. The same approach also scales to other AI internal tools like support triage, lead scoring, and ticket classification once the patterns are in place.

The ATS has three layers:

• ToolJet for the recruiter dashboard
• ToolJet DB for applicant data
• OpenAI for candidate evaluation logic

The data flow:

1. Recruiter adds applicants and jobs through the dashboard
2. Recruiter selects a candidate row
3. Clicking “Analyse with AI” sends the candidate and matched job description to OpenAI
4. OpenAI returns structured JSON with score, match, notes, strengths, and gaps
5. Results display in a side panel

The architecture is intentionally minimal. Everything operational lives inside ToolJet. There’s no separate service to deploy, no orchestration layer, and no backend to maintain.

Start with the data. ToolJet DB is built into the platform, so there’s no separate setup or external service to connect.

Fig 2: Setting up ToolJet DB

Create two tables:

• ats_jobs for open roles

Column	Notes
id	Auto-incremented
position	e.g. “Software Engineer”
description	Full role description used by the AI
experience_level	e.g. “Mid-Senior level”
active	Used to filter the open-jobs view
created_at	Auto-set on insert

• ats_applicants for candidate records

Column	Notes
id	Auto-incremented
name	Applicant full name
email	Primary contact
phone_number	Optional
linkedin_url	LinkedIn profile
resume	Resume file URL or extracted text
job_id	Role being applied to
job_position	Denormalised for display
application_status	Pipeline stage
application_date	When applicant entered pipeline
notes	Recruiter notes

Add a few extra columns to applicants: ai_score, ai_match, ai_notes, ai_strengths, and ai_gaps

Add a handful of sample rows so the dashboard has something to display. ToolJet DB has a built-in row editor, so you can type entries directly without writing SQL.

Before building the UI, confirm that OpenAI is reachable from inside ToolJet.

Head into the queries panel and add a new data source. Choose OpenAI, paste your API key, and test your connection.

Fig 3: Testing OpenAI Connection

Quick sanity check:

• Create a test query
• Select OpenAI as source
• Pick model gpt-4o-mini
• Send a small prompt like “ping”
• Confirm response returns successfully

If you see a response, the integration is working. If you hit a quota or billing error, fix that first because every later step depends on this call succeeding. You can delete the test query once you’ve confirmed it works.

Now build the recruiter dashboard visually. The goal at this stage is just to lay out the components. We’ll wire them to data in the next step.

Fig 4: Component Library

Drop these components onto the canvas:

• A header bar at top
• An applicants table in the middle
• Filter dropdowns above the table
• An add applicant button
• An AI analysis container on the right

Inside the AI analysis container, stack text components for applicant name, job position, score, match percentage, summary, strengths, and gaps. At the bottom of that container, add a button labelled something like “Analyse with AI” in a strong brand color so it stands out as the primary action.

For the add applicant flow, drop a modal with text inputs for name, email, LinkedIn, phone, and resume, plus a dropdown for the job and one for application status.

Fig 5: Add Applications Form

Add the Jobs page,

Fig 6: Jobs page

Create a second page in the same app called “View Jobs” with its own table bound to getActiveJobs. Add a similar Add/Update workflow for jobs so recruiters can manage the open-role list without leaving the tool. The Jobs page is a smaller mirror of the Applicants page and reuses the same query patterns.

Don’t worry about renaming components or perfecting styling yet. Just get the structure in place.

Now the components need data. Create a handful of queries pointing to ToolJet DB:

• One to list all applicants
• One to list all jobs
• One to insert applicants
• One to update applicant status
• One to update AI results

Fig 7: ToolJet Query Panel

Bind the applicants table to the list-applicants query. Bind the job dropdown inside your add applicant modal to the list-jobs query. Add filter conditions on the list-applicants query so it responds to the position and status dropdowns at the top of the page.

For the AI evaluation, create one more query using your OpenAI data source. Set the model to gpt-4o-mini, set response format to JSON object, and use a system prompt that asks for structured JSON output with score, match, notes, strengths, and gaps fields.

Fig 8: OpenAI Query

In the user prompt, pull the selected row’s data from the applicants table. ToolJet’s templating handles this with curly-brace expressions referencing the table’s selected row values.

This is where everything starts working together.

Fig 9: Adding Event Handlers

Wire up these click and event flows:

• Add applicant button opens modal
• Modal submit runs insert query
• Successful insert refreshes the table
• Analyse button runs OpenAI query
• AI success chains an update

For the Analyse button specifically, the click should run the OpenAI query. Once the query succeeds, the AI panel populates automatically through ToolJet’s reactive bindings, no extra wiring needed.

Test the full flow end to end. Add a candidate, pick a row, click Analyse, and watch the AI panel fill in.

Once the app works, lock it down before sharing.

ToolJet has role-based access controls built in. From the workspace settings, you can:

• Define recruiter and admin roles
• Restrict editing to admins only
• Limit query visibility per group
• Hide sensitive applicant columns
• Audit who changed what data

Invite teammates by email from the same settings panel. Assign each person to a role so recruiters see the dashboard in preview mode while admins keep edit access. This matters because applicant data is sensitive, and a careless edit to a query or table can break the entire workflow for the team.

If you’re self-hosting ToolJet, you can also enable SSO so recruiters log in with their existing work account, which makes onboarding cleaner and revocation easier when someone leaves.

With access controls in place, share the app link with your team and you’re live.

Fig 10: Final Preview of the Applicant Tracking System

Three things make AI evaluation reliable:

1. Use gpt-4o-mini for speed and cost. Evaluations cost fractions of a cent and complete in 1 to 2 seconds. Reserve larger models for batch ranking, deeper resume parsing, or candidate-comparison flows.
2. Pass context, not just the applicant. Including the matched job description in the prompt gives the model something to evaluate against. Without it, scores become arbitrary numbers that drift across roles.

For higher reliability in production, you can also:

• Validate JSON against a schema
• Store raw response for debugging
• Retry on missing required fields
• Version prompts inside source control
• Log token usage per request

The MVP covers the core evaluation loop. From here, the same architecture supports a long list of extensions.

Run analyseApplicant across every applicant for an open role and store the scores. Then expose a “Ranked Candidates” view that sorts by ai_score and groups by job position. Especially useful when an inbound spike of applications arrives. Recruiters can prioritise the top decile within minutes.

Trigger templated emails from ToolJet workflows when a candidate’s status changes. Pair this with an AI-drafted email body (for example, “Write a polite rejection that references the candidate’s strengths”) and recruiters can send personalised responses at scale.

Generate embeddings for each candidate’s resume and LinkedIn summary, store them in a vector store (Pinecone), and add a natural-language search box. “Senior Python engineers with SaaS experience” returns the most semantically relevant applicants, not just keyword matches.

After an interview, paste the transcript into a new query that returns summary, strengths shown in the interview, concerns, and a recommended next step. Append it to the applicant’s notes field automatically.

Each of these is a self-contained workflow that plugs into the same applicant and job data model. The ATS gets more useful with every layer you add.

A few things to handle before this becomes a real recruiter-facing tool:

• PII handling and access controls
• OpenAI rate limits and throttling
• Human review of all decisions
• GDPR and candidate privacy compliance
• Bias monitoring across demographic dimensions

Resumes and contact info are sensitive. Don’t log raw applicant data in OpenAI request logs, and use ToolJet’s role-based access controls to limit who sees what.

AI evaluations should support recruiters, not replace them. Keep manual status changes, recruiter notes, and final hiring decisions as first-class fields. If you operate in the EU, document the AI processing step in your candidate privacy policy, offer deletion workflows, and consider an opt-out flag on the applicant record.

AI-driven ranking can replicate or amplify biases present in historical data. Monitor score distributions across demographic dimensions where you have consent to do so, and treat AI scores as one signal, not a gate.

Building the same ATS in React would take significantly longer. A quick comparison:

• React needs separate frontend setup
• ToolJet ships UI, queries, auth
• Custom builds require dedicated engineers
• ToolJet enables non-engineers to contribute
• Iteration is hours, not sprints

For internal tools where speed of iteration matters more than full design control, the low-code stack wins on almost every dimension.

Internal recruiting software has historically been heavy to build. A custom React frontend, a Postgres backend, auth, queries, and now an AI layer on top.

ToolJet collapses most of this. You get:

• Visual dashboard builder out-of-box
• ToolJet DB as data layer
• Native OpenAI data source
• Event handlers chaining queries together
• Self-hosting with open-source licensing

For HR-tech MVPs, internal recruiting platforms, or any team that wants a working AI demo in a day, the low-code ATS platform stack delivers. Once the patterns are in place, the same approach extends to lead scoring, ticket triage, support routing, and dozens of other internal AI workflows.

You can build this ATS, or any variation of it, entirely inside ToolJet. Connect OpenAI, point queries at ToolJet DB, drop the components onto the canvas, and you have a working AI recruiting workflow in under an hour.