Round #474

A manager wants to put just one employee at risk of redundancy rather than run a pool selection. In what circumstances is a pool of one lawful?

A pool of one is lawful where the employer can show that its choice of pool fell within the "band of reasonable responses" (Capita Hartshead Ltd v Byard [2012] IRLR 814). This is most commonly accepted in the following circumstances: - The employee performs a genuinely unique or standalone role with no other employees carrying out work of a similar kind (ERA 1996, s 139(1)(b)). - The redundancy arises from the elimination of a specific post or function rather than a general reduction in numbers across a group of interchangeable employees. - There is no obvious "pool of more than one" that a reasonable employer would have considered (e.g., the employee is the only person in a specialist technical, managerial or client-facing role with no overlap). - The employer has documented, at the time, why it concluded that no other roles were similar or interchangeable. In these situations tribunals have upheld a pool of one as fair, provided the remainder of the redundancy process (consultation, search for alternatives, etc.) is also fair. Conversely, a pool of one will usually be unfair if other employees are doing broadly similar work and the employer has simply chosen to single out one individual without objective justification.

```csharp using System; using System.Collections.Generic; using System.Linq; using Microsoft.Extensions.DependencyInjection; namespace Company.HR.Redundancy { public record Employee(string Id, string Name, string Role, string Department, DateTime StartDate); public interface ISelectionCriteria { bool EvaluatePoolOfOne(Employee target, IReadOnlyList<Employee> candidatePool); } public sealed class UniqueRoleSelectionCriteria : ISelectionCriteria { public bool EvaluatePoolOfOne(Employee target, IReadOnlyList<Employee> candidatePool) { if (target is null) throw new ArgumentNullException(nameof(target)); if (candidatePool is null) throw new ArgumentNullException(nameof(candidatePool)); // Lawful pool-of-one only when the role is genuinely unique var similarRoles = candidatePool .Where(e => e.Role.Equals(target.Role, StringComparison.OrdinalIgnoreCase) && e.Department.Equals(target.Department, StringComparison.OrdinalIgnoreCase) && e.Id != target.Id) .ToList(); return similarRoles.Count == 0; } } public interface IRedundancyProcess { void IssueAtRiskNotification(Employee employee); bool CanUsePoolOfOne(Employee employee, IReadOnlyList<Employee> allEmployees); } public sealed class RedundancyProcess : IRedundancyProcess { private readonly ISelectionCriteria _selectionCriteria; public RedundancyProcess(ISelectionCriteria selectionCriteria) { _selectionCriteria = selectionCriteria ?? throw new ArgumentNullException(nameof(selectionCriteria)); } public bool CanUsePoolOfOne(Employee employee, IReadOnlyList<Employee> allEmployees) { if (employee is null) throw new ArgumentNullException(nameof(employee)); if (allEmployees is null || allEmployees.Count == 0) throw new ArgumentException("Employee list cannot be empty", nameof(allEmployees)); return _selectionCriteria.EvaluatePoolOfOne(employee, allEmployees); } public void IssueAtRiskNotification(Employee employee) { if (employee is null) throw new ArgumentNullException(nameof(employee)); Console.WriteLine($"At-risk notification issued to {employee.Name} ({employee.Id})"); } } } // Example DI registration (Program.cs / Startup.cs) public static class ServiceCollectionExtensions { public static IServiceCollection AddRedundancyServices(this IServiceCollection services) { services.AddScoped<ISelectionCriteria, UniqueRoleSelectionCriteria>(); services.AddScoped<IRedundancyProcess, RedundancyProcess>(); return services; } } ``` A pool of one is lawful when the employee’s role is genuinely unique—no other employees perform work of a similar kind in the same department or location. In that situation the employer is not required to create an artificial pool simply to compare the individual against colleagues who do different work. The code above encapsulates this test via `UniqueRoleSelectionCriteria.EvaluatePoolOfOne`, which returns true only when no comparable colleagues exist. The `RedundancyProcess` service then uses the result to decide whether an at-risk notification can be issued directly, while still allowing the normal individual-consultation and statutory-redundancy-pay steps to follow.