> For the complete documentation index, see [llms.txt](https://help.join.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.join.com/review-candidates/application-stage.md).

# Application stage

Learn how application stages and hiring states track each application, and change an application's stage or reject it from a table, the cards or a profile.

In JOIN, an *application stage* reflects the current step a candidate’s application has reached in your hiring process — such as screening, interview, offer, or hired. This stage is part of the customised pipeline you set for each job and helps your team track progress, coordinate next steps, and communicate with candidates.

Each time someone applies to a job via JOIN, a separate application is created and added to your company’s account. If a candidate applies to multiple jobs, you’ll see multiple applications — each one tracked independently, with its own stage and outcome, so each position gets its own review.

By keeping application stages up to date, your hiring team can stay aligned, avoid delays, and keep candidates informed across all open roles.

***

## Application

An application in JOIN is a single submission made by a candidate to one of your job postings. If a candidate applies to multiple roles, each submission is tracked as a separate application.

Each application includes:

* Candidate details
* CV and any attachments
* Source and date applied
* Current pipeline stage (which determines the application’s state)
* GDPR status

You can view all of a candidate’s applications in their profile, shown on the top of the right-most panel in the `Candidate Profile` view.

***

## Application stage

The application stage represents the current step in the hiring process for a specific application. These stages reflect your pipeline setup — you can customise them in each pipeline, apart from the fixed stages `Applied`, `Application review`, `Offer` and `Hired`, which can't be renamed or removed. Some examples of application stage include: Screening, Phone Interview, Offer, Hired

JOIN uses the selected stage to define the application state, which is visible in the `Candidates` tab and in each candidate's profile. These appear in the `Stage` column of the table in the `Candidates` tab and in a job's `Applications` tab, so you can track and move candidates.

You can have different stages across jobs depending on how your hiring pipeline is structured. These stages are user-defined when you [create or edit a pipeline](https://help.join.com/review-candidates/pipeline-management.md#create-a-pipeline-template).

***

## Hiring state

The hiring state is a system-level summary of where the application is in your hiring process. JOIN uses fixed labels — `Active`, `Offer`, `Hired` and `Rejected` — to help you filter and organise your applications.

Application states are automatically mapped based on the stage the application is currently in.

These system-level hiring states help with filtering and reporting:

| State    | Description                                                  |
| -------- | ------------------------------------------------------------ |
| Active   | Application is in `Application review` or an interview stage |
| Offer    | Candidate has received or is being considered for an offer   |
| Hired    | Application has been marked as hired                         |
| Rejected | Application has been rejected                                |

The `Hiring state` filter in your `Candidates` tab lets you track and manage candidates by the overall state of an application.

***

## View and manage application stages

You can view and manage application stages in three key areas:

### Candidates overview

Go to `Candidates` > `Active`

* View all candidates and their applications across all jobs in a table view
* The `Stage` column shows the current stage (and determines the state)
* Click the stage to update it

### Job-specific applications

Go to `Jobs` > Select a job > `Applications`

* View applications for that job only
* Use card view or table view
* Each card or row is a separate application with its own stage

### Candidate profile

Click into a candidate’s profile

* See all their applications on the right-hand panel
* Each application is listed with its associated job and current stage
* Click on an application to manage its stage

***

## Change the application stage

Changing an application’s stage updates its state automatically.

### From table view (all jobs or one job)

1. Go to the `Stage` column
2. Click the current stage
3. Select a new stage from the list

### From the candidate profile

1. Click the `Move forward` button to go to the next stage
2. Or use the dropdown arrow to select a specific stage

### From cards view

1. Drag the application card into another stage column
2. The new stage is applied immediately

{% hint style="info" %}
Applications must be updated individually, even if they come from the same candidate.
{% endhint %}

***

## Reject an application

To reject an application:

1. Use the `Reject` action on the application (rejection is an action, not a pipeline stage)
2. The application state updates to `Rejected`
3. The application is removed from the active hiring pipeline
4. You can manually send a rejection message, or use an automated one if configured

{% hint style="info" %}
Rejections apply **only to the specific application**, not the candidate. Other applications remain active unless individually rejected.
{% endhint %}

For every way to reject, see [Reject, delete or block](https://help.join.com/review-candidates/reject-delete-or-block.md#reject-a-candidate).

***

## Importance of moving applications through stages

Keeping applications updated helps your team:

* Stay aligned on candidate progress
* Identify where applicants are getting stuck
* Keep your pipeline tidy and actionable
* Enable accurate filtering and reporting

It also means candidates get timely responses with fewer delays.

***

## One candidate – multiple applications

JOIN allows a single candidate to apply to multiple roles. Each application:

* Has its own evaluations (tags and notes belong to the candidate and are shared across their applications)
* Moves independently through the pipeline
* Can result in different outcomes (e.g. hired for one, rejected for another)

You’ll see all applications tied to a candidate in their profile, giving you full context during reviews.

***

## Best practices

* Update application stages regularly to reflect true progress
* Use filters (e.g. `Job`, `Hiring state`) to review applications in similar stages
* Add scorecards to each application individually (tags and notes apply to the candidate across all of their applications)
* Regularly review applications in `Application review` so none are missed


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://help.join.com/review-candidates/application-stage.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
