diff --git a/backend/src/abdulrcrtw.spec.ts b/backend/src/abdulrcrtw.spec.ts
index bf9f4d945..5cb160653 100644
--- a/backend/src/abdulrcrtw.spec.ts
+++ b/backend/src/abdulrcrtw.spec.ts
@@ -32,6 +32,7 @@ describe('abdulrcrtw Modules (BE-92, BE-91, BE-90, BE-89)', () => {
       assetId: 'ast-1',
       title: 'Screen repair',
       cost: 15000,
+      scheduledDate: '2026-01-01',
     });
     expect(rec.cost).toBe(15000);
   });
diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts
index 8b48554fd..092846d4e 100644
--- a/backend/src/app.module.ts
+++ b/backend/src/app.module.ts
@@ -21,6 +21,7 @@ import { InventoryModule } from './inventory/inventory.module';
 import { VendorsModule } from './vendors/vendors.module';
 import { PurchaseOrdersModule } from './purchase-orders/purchase-orders.module';
 import { LicensesModule } from './licenses/licenses.module';
+import { AuditsModule } from './audits/audits.module';
 import { NotificationsModule } from './notifications/notifications.module';
 import { GatewayModule } from './gateway/gateway.module';
 import { AuditLogsModule } from './audit-logs/audit-logs.module';
@@ -45,6 +46,7 @@ import { AuditLogsModule } from './audit-logs/audit-logs.module';
     VendorsModule,
     PurchaseOrdersModule,
     LicensesModule,
+    AuditsModule,
     NotificationsModule,
     GatewayModule,
     AuditLogsModule,
diff --git a/backend/src/audits/audits.controller.ts b/backend/src/audits/audits.controller.ts
new file mode 100644
index 000000000..c24e054a5
--- /dev/null
+++ b/backend/src/audits/audits.controller.ts
@@ -0,0 +1,54 @@
+import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { AuditsService } from './audits.service';
+import { CreateAuditSessionDto } from './dto/create-audit-session.dto';
+import { RecordAuditItemDto } from './dto/record-audit-item.dto';
+
+@ApiTags('audits')
+@Controller('audits')
+export class AuditsController {
+  constructor(private readonly auditsService: AuditsService) {}
+
+  @Get()
+  @ApiOperation({
+    summary: 'List audit sessions with scope, status and progress',
+  })
+  findAll() {
+    return this.auditsService.findAll();
+  }
+
+  @Post()
+  @ApiOperation({
+    summary: 'Start an audit session (generates the expected-assets checklist)',
+  })
+  create(@Body() dto: CreateAuditSessionDto) {
+    return this.auditsService.create(dto);
+  }
+
+  @Get(':id')
+  @ApiOperation({
+    summary: 'Get an audit session with its checklist and discrepancy summary',
+  })
+  findOne(@Param('id') id: string) {
+    return this.auditsService.findById(id);
+  }
+
+  @Patch(':id/items/:itemId')
+  @ApiOperation({
+    summary:
+      'Record a checklist item result (Found / Missing / Wrong location / Damaged)',
+  })
+  recordItem(
+    @Param('id') id: string,
+    @Param('itemId') itemId: string,
+    @Body() dto: RecordAuditItemDto,
+  ) {
+    return this.auditsService.recordItem(id, itemId, dto);
+  }
+
+  @Post(':id/complete')
+  @ApiOperation({ summary: 'Complete the audit session (becomes immutable)' })
+  complete(@Param('id') id: string) {
+    return this.auditsService.complete(id);
+  }
+}
diff --git a/backend/src/audits/audits.module.ts b/backend/src/audits/audits.module.ts
new file mode 100644
index 000000000..d652ebaa7
--- /dev/null
+++ b/backend/src/audits/audits.module.ts
@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AuditSession } from './entities/audit-session.entity';
+import { AuditItem } from './entities/audit-item.entity';
+import { Asset } from '../assets/entities/asset.entity';
+import { AuditsService } from './audits.service';
+import { AuditsController } from './audits.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([AuditSession, AuditItem, Asset])],
+  providers: [AuditsService],
+  controllers: [AuditsController],
+  exports: [AuditsService],
+})
+export class AuditsModule {}
diff --git a/backend/src/audits/audits.service.ts b/backend/src/audits/audits.service.ts
new file mode 100644
index 000000000..0ad919d30
--- /dev/null
+++ b/backend/src/audits/audits.service.ts
@@ -0,0 +1,153 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import {
+  AuditSession,
+  AuditSessionStatus,
+} from './entities/audit-session.entity';
+import { AuditItem, AuditItemResult } from './entities/audit-item.entity';
+import { Asset } from '../assets/entities/asset.entity';
+import { CreateAuditSessionDto } from './dto/create-audit-session.dto';
+import { RecordAuditItemDto } from './dto/record-audit-item.dto';
+
+@Injectable()
+export class AuditsService {
+  constructor(
+    @InjectRepository(AuditSession)
+    private readonly sessionRepo: Repository<AuditSession>,
+    @InjectRepository(AuditItem)
+    private readonly itemRepo: Repository<AuditItem>,
+    @InjectRepository(Asset)
+    private readonly assetRepo: Repository<Asset>,
+  ) {}
+
+  private summarize(session: AuditSession, items: AuditItem[]) {
+    const total = items.length;
+    const checked = items.filter(
+      (i) => i.result !== AuditItemResult.PENDING,
+    ).length;
+    const discrepancies = items.filter(
+      (i) =>
+        i.result !== AuditItemResult.PENDING &&
+        i.result !== AuditItemResult.FOUND,
+    );
+    return {
+      ...session,
+      totalItems: total,
+      checkedItems: checked,
+      progressPercent: total === 0 ? 0 : Math.round((checked / total) * 100),
+      discrepancyCount: discrepancies.length,
+    };
+  }
+
+  async findAll() {
+    const sessions = await this.sessionRepo.find({
+      order: { createdAt: 'DESC' },
+    });
+    const results = [];
+    for (const session of sessions) {
+      const items = await this.itemRepo.find({
+        where: { auditSessionId: session.id },
+      });
+      results.push(this.summarize(session, items));
+    }
+    return results;
+  }
+
+  async findById(id: string) {
+    const session = await this.sessionRepo.findOne({ where: { id } });
+    if (!session) throw new NotFoundException(`Audit session ${id} not found`);
+    const items = await this.itemRepo.find({
+      where: { auditSessionId: id },
+      order: { createdAt: 'ASC' },
+    });
+    return { ...this.summarize(session, items), items };
+  }
+
+  async create(dto: CreateAuditSessionDto, actorId?: string) {
+    if (!dto.departmentId && !dto.locationId) {
+      throw new BadRequestException(
+        'An audit session needs a department or location scope',
+      );
+    }
+
+    const qb = this.assetRepo.createQueryBuilder('asset');
+    if (dto.departmentId)
+      qb.andWhere('asset.departmentId = :d', { d: dto.departmentId });
+    if (dto.locationId)
+      qb.andWhere('asset.locationId = :l', { l: dto.locationId });
+    const assets = await qb.getMany();
+
+    if (assets.length === 0) {
+      throw new BadRequestException('No assets match the selected scope');
+    }
+
+    const session = this.sessionRepo.create({
+      name: dto.name,
+      scopeDepartmentId: dto.departmentId,
+      scopeLocationId: dto.locationId,
+      createdByUserId: actorId,
+      status: AuditSessionStatus.DRAFT,
+    });
+    const savedSession = await this.sessionRepo.save(session);
+
+    const items = assets.map((asset) =>
+      this.itemRepo.create({
+        auditSessionId: savedSession.id,
+        assetId: asset.id,
+        expectedLocationId: asset.locationId,
+        result: AuditItemResult.PENDING,
+      }),
+    );
+    await this.itemRepo.save(items);
+
+    return this.findById(savedSession.id);
+  }
+
+  private async getMutableSession(id: string): Promise<AuditSession> {
+    const session = await this.sessionRepo.findOne({ where: { id } });
+    if (!session) throw new NotFoundException(`Audit session ${id} not found`);
+    if (session.status === AuditSessionStatus.COMPLETED) {
+      throw new BadRequestException(
+        'This audit session is completed and can no longer be edited',
+      );
+    }
+    return session;
+  }
+
+  async recordItem(sessionId: string, itemId: string, dto: RecordAuditItemDto) {
+    const session = await this.getMutableSession(sessionId);
+
+    const item = await this.itemRepo.findOne({
+      where: { id: itemId, auditSessionId: sessionId },
+    });
+    if (!item)
+      throw new NotFoundException(
+        `Audit item ${itemId} not found in this session`,
+      );
+
+    item.result = dto.result;
+    item.note = dto.note;
+    item.checkedAt = new Date();
+    await this.itemRepo.save(item);
+
+    if (session.status === AuditSessionStatus.DRAFT) {
+      session.status = AuditSessionStatus.IN_PROGRESS;
+      await this.sessionRepo.save(session);
+    }
+
+    return this.findById(sessionId);
+  }
+
+  async complete(sessionId: string) {
+    const session = await this.getMutableSession(sessionId);
+    session.status = AuditSessionStatus.COMPLETED;
+    session.completedAt = new Date();
+    await this.sessionRepo.save(session);
+    return this.findById(sessionId);
+  }
+}
diff --git a/backend/src/audits/dto/create-audit-session.dto.ts b/backend/src/audits/dto/create-audit-session.dto.ts
new file mode 100644
index 000000000..10535216e
--- /dev/null
+++ b/backend/src/audits/dto/create-audit-session.dto.ts
@@ -0,0 +1,14 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class CreateAuditSessionDto {
+  @IsString()
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  departmentId?: string;
+
+  @IsOptional()
+  @IsString()
+  locationId?: string;
+}
diff --git a/backend/src/audits/dto/record-audit-item.dto.ts b/backend/src/audits/dto/record-audit-item.dto.ts
new file mode 100644
index 000000000..678671d03
--- /dev/null
+++ b/backend/src/audits/dto/record-audit-item.dto.ts
@@ -0,0 +1,11 @@
+import { IsEnum, IsOptional, IsString } from 'class-validator';
+import { AuditItemResult } from '../entities/audit-item.entity';
+
+export class RecordAuditItemDto {
+  @IsEnum(AuditItemResult)
+  result: AuditItemResult;
+
+  @IsOptional()
+  @IsString()
+  note?: string;
+}
diff --git a/backend/src/audits/entities/audit-item.entity.ts b/backend/src/audits/entities/audit-item.entity.ts
new file mode 100644
index 000000000..c8d278966
--- /dev/null
+++ b/backend/src/audits/entities/audit-item.entity.ts
@@ -0,0 +1,48 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  Index,
+} from 'typeorm';
+
+export enum AuditItemResult {
+  PENDING = 'PENDING',
+  FOUND = 'FOUND',
+  MISSING = 'MISSING',
+  WRONG_LOCATION = 'WRONG_LOCATION',
+  DAMAGED = 'DAMAGED',
+}
+
+@Entity('audit_items')
+export class AuditItem {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Index()
+  @Column()
+  auditSessionId: string;
+
+  @Column()
+  assetId: string;
+
+  /** Snapshot of the asset's expected location at the time the checklist was generated. */
+  @Column({ nullable: true })
+  expectedLocationId?: string;
+
+  @Column({
+    type: 'enum',
+    enum: AuditItemResult,
+    default: AuditItemResult.PENDING,
+  })
+  result: AuditItemResult;
+
+  @Column({ nullable: true })
+  note?: string;
+
+  @Column({ nullable: true })
+  checkedAt?: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+}
diff --git a/backend/src/audits/entities/audit-session.entity.ts b/backend/src/audits/entities/audit-session.entity.ts
new file mode 100644
index 000000000..c053250ff
--- /dev/null
+++ b/backend/src/audits/entities/audit-session.entity.ts
@@ -0,0 +1,47 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+export enum AuditSessionStatus {
+  DRAFT = 'DRAFT',
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+}
+
+@Entity('audit_sessions')
+export class AuditSession {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column({
+    type: 'enum',
+    enum: AuditSessionStatus,
+    default: AuditSessionStatus.DRAFT,
+  })
+  status: AuditSessionStatus;
+
+  @Column({ nullable: true })
+  scopeDepartmentId?: string;
+
+  @Column({ nullable: true })
+  scopeLocationId?: string;
+
+  @Column({ nullable: true })
+  createdByUserId?: string;
+
+  @Column({ nullable: true })
+  completedAt?: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}
diff --git a/backend/src/femaleotaku.spec.ts b/backend/src/femaleotaku.spec.ts
index 08d7b231c..e6e90e315 100644
--- a/backend/src/femaleotaku.spec.ts
+++ b/backend/src/femaleotaku.spec.ts
@@ -13,7 +13,10 @@ describe('femaleotaku Modules (BE-88, BE-87, BE-85, BE-84)', () => {
         .fn()
         .mockImplementation((dto) => Promise.resolve({ id: 'loc-1', ...dto })),
     };
-    const service = new LocationsService(mockRepo as any);
+    const mockAssetRepo = {
+      count: jest.fn().mockResolvedValue(0),
+    };
+    const service = new LocationsService(mockRepo as any, mockAssetRepo as any);
     const loc = await service.create({ name: 'Building A', code: 'BLD-A' });
     expect(loc.name).toBe('Building A');
   });
diff --git a/backend/src/ibinola.spec.ts b/backend/src/ibinola.spec.ts
index ed1f44b03..e68d9e273 100644
--- a/backend/src/ibinola.spec.ts
+++ b/backend/src/ibinola.spec.ts
@@ -49,9 +49,12 @@ describe('ibinola Modules (BE-96, BE-95, BE-94, BE-93)', () => {
       findOne: jest.fn().mockResolvedValue(lic),
       save: jest.fn().mockImplementation((dto) => Promise.resolve(dto)),
     };
-    const service = new LicensesService(mockRepo as any);
+    const mockSeatRepo = {
+      findOne: jest.fn().mockResolvedValue(null),
+    };
+    const service = new LicensesService(mockRepo as any, mockSeatRepo as any);
 
-    await expect(service.assign('lic-1', 'u-1')).rejects.toThrow(
+    await expect(service.assign('lic-1', { userId: 'u-1' })).rejects.toThrow(
       'No available seats remaining for this license',
     );
   });
diff --git a/backend/src/licenses/dto/assign-seat.dto.ts b/backend/src/licenses/dto/assign-seat.dto.ts
new file mode 100644
index 000000000..3be49b90d
--- /dev/null
+++ b/backend/src/licenses/dto/assign-seat.dto.ts
@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class AssignSeatDto {
+  @IsString()
+  userId: string;
+}
diff --git a/backend/src/licenses/dto/create-license.dto.ts b/backend/src/licenses/dto/create-license.dto.ts
new file mode 100644
index 000000000..0d07cc9b2
--- /dev/null
+++ b/backend/src/licenses/dto/create-license.dto.ts
@@ -0,0 +1,56 @@
+import {
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsPositive,
+  IsString,
+  IsDateString,
+} from 'class-validator';
+import { LicenseType, BillingPeriod } from '../entities/license.entity';
+
+export class CreateLicenseDto {
+  @IsString()
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  vendorId?: string;
+
+  @IsString()
+  licenseKey: string;
+
+  @IsOptional()
+  @IsEnum(LicenseType)
+  type?: LicenseType;
+
+  @IsOptional()
+  @IsEnum(BillingPeriod)
+  billingPeriod?: BillingPeriod;
+
+  @IsInt()
+  @IsPositive()
+  seatsTotal: number;
+
+  @IsOptional()
+  @IsDateString()
+  startDate?: string;
+
+  @IsOptional()
+  @IsDateString()
+  expiryDate?: string;
+
+  @IsOptional()
+  @IsInt()
+  cost?: number;
+
+  @IsOptional()
+  @IsString()
+  currency?: string;
+
+  @IsOptional()
+  autoRenew?: boolean;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/backend/src/licenses/dto/update-license.dto.ts b/backend/src/licenses/dto/update-license.dto.ts
new file mode 100644
index 000000000..3f500e4a8
--- /dev/null
+++ b/backend/src/licenses/dto/update-license.dto.ts
@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateLicenseDto } from './create-license.dto';
+
+export class UpdateLicenseDto extends PartialType(CreateLicenseDto) {}
diff --git a/backend/src/licenses/entities/license-seat-assignment.entity.ts b/backend/src/licenses/entities/license-seat-assignment.entity.ts
new file mode 100644
index 000000000..99d4e5d54
--- /dev/null
+++ b/backend/src/licenses/entities/license-seat-assignment.entity.ts
@@ -0,0 +1,26 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  Index,
+} from 'typeorm';
+
+@Entity('license_seat_assignments')
+export class LicenseSeatAssignment {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Index()
+  @Column()
+  licenseId: string;
+
+  @Column()
+  userId: string;
+
+  @CreateDateColumn()
+  assignedAt: Date;
+
+  @Column({ nullable: true })
+  unassignedAt?: Date;
+}
diff --git a/backend/src/licenses/entities/license.entity.ts b/backend/src/licenses/entities/license.entity.ts
index 952b046c8..896016d41 100644
--- a/backend/src/licenses/entities/license.entity.ts
+++ b/backend/src/licenses/entities/license.entity.ts
@@ -11,6 +11,12 @@ export enum LicenseType {
   SUBSCRIPTION = 'SUBSCRIPTION',
 }
 
+export enum BillingPeriod {
+  MONTHLY = 'MONTHLY',
+  YEARLY = 'YEARLY',
+  ONE_TIME = 'ONE_TIME',
+}
+
 @Entity('software_licenses')
 export class License {
   @PrimaryGeneratedColumn('uuid')
@@ -32,6 +38,9 @@ export class License {
   })
   type: LicenseType;
 
+  @Column({ type: 'enum', enum: BillingPeriod, default: BillingPeriod.YEARLY })
+  billingPeriod: BillingPeriod;
+
   @Column({ type: 'integer', default: 1 })
   seatsTotal: number;
 
@@ -53,6 +62,9 @@ export class License {
   @Column({ default: false })
   autoRenew: boolean;
 
+  @Column({ nullable: true })
+  notes?: string;
+
   @CreateDateColumn()
   createdAt: Date;
 
diff --git a/backend/src/licenses/licenses.controller.ts b/backend/src/licenses/licenses.controller.ts
index 8e0399225..2d8efa925 100644
--- a/backend/src/licenses/licenses.controller.ts
+++ b/backend/src/licenses/licenses.controller.ts
@@ -1,4 +1,12 @@
-import { Controller, Get, Post, Param, Body } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Param,
+  Body,
+} from '@nestjs/common';
 import {
   ApiTags,
   ApiOperation,
@@ -6,6 +14,9 @@ import {
   ApiResponse,
 } from '@nestjs/swagger';
 import { LicensesService } from './licenses.service';
+import { CreateLicenseDto } from './dto/create-license.dto';
+import { UpdateLicenseDto } from './dto/update-license.dto';
+import { AssignSeatDto } from './dto/assign-seat.dto';
 
 @ApiTags('licenses')
 @ApiBearerAuth('JWT-auth')
@@ -23,7 +34,7 @@ export class LicensesController {
   @Post()
   @ApiOperation({ summary: 'Create a software license' })
   @ApiResponse({ status: 201, description: 'License created' })
-  create(@Body() dto: any) {
+  create(@Body() dto: CreateLicenseDto) {
     return this.licensesService.create(dto);
   }
 
@@ -35,10 +46,46 @@ export class LicensesController {
     return this.licensesService.findById(id);
   }
 
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a license' })
+  update(@Param('id') id: string, @Body() dto: UpdateLicenseDto) {
+    return this.licensesService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a license' })
+  delete(@Param('id') id: string) {
+    return this.licensesService.delete(id);
+  }
+
+  @Post(':id/reveal-key')
+  @ApiOperation({
+    summary:
+      'Reveal the plaintext license key (explicit click-to-reveal action)',
+  })
+  revealKey(@Param('id') id: string) {
+    return this.licensesService.revealKey(id);
+  }
+
+  @Get(':id/assignments')
+  @ApiOperation({ summary: 'List active seat assignments for a license' })
+  getAssignments(@Param('id') id: string) {
+    return this.licensesService.getAssignments(id);
+  }
+
   @Post(':id/assign')
-  @ApiOperation({ summary: 'Assign a license seat' })
+  @ApiOperation({ summary: 'Assign a license seat to a user' })
   @ApiResponse({ status: 201, description: 'License seat assigned' })
-  assign(@Param('id') id: string, @Body('assigneeId') assigneeId: string) {
-    return this.licensesService.assign(id, assigneeId);
+  assign(@Param('id') id: string, @Body() dto: AssignSeatDto) {
+    return this.licensesService.assign(id, dto);
+  }
+
+  @Post(':id/assignments/:assignmentId/unassign')
+  @ApiOperation({ summary: 'Release a seat assignment' })
+  unassign(
+    @Param('id') id: string,
+    @Param('assignmentId') assignmentId: string,
+  ) {
+    return this.licensesService.unassign(id, assignmentId);
   }
 }
diff --git a/backend/src/licenses/licenses.module.ts b/backend/src/licenses/licenses.module.ts
index 294a513a9..f649df503 100644
--- a/backend/src/licenses/licenses.module.ts
+++ b/backend/src/licenses/licenses.module.ts
@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { License } from './entities/license.entity';
+import { LicenseSeatAssignment } from './entities/license-seat-assignment.entity';
 import { LicensesService } from './licenses.service';
 import { LicensesController } from './licenses.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([License])],
+  imports: [TypeOrmModule.forFeature([License, LicenseSeatAssignment])],
   providers: [LicensesService],
   controllers: [LicensesController],
   exports: [LicensesService],
diff --git a/backend/src/licenses/licenses.service.ts b/backend/src/licenses/licenses.service.ts
index 848d3d777..5a78b2f4a 100644
--- a/backend/src/licenses/licenses.service.ts
+++ b/backend/src/licenses/licenses.service.ts
@@ -2,42 +2,132 @@ import {
   Injectable,
   NotFoundException,
   ConflictException,
+  BadRequestException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { IsNull, Repository } from 'typeorm';
 import { License } from './entities/license.entity';
+import { LicenseSeatAssignment } from './entities/license-seat-assignment.entity';
+import { CreateLicenseDto } from './dto/create-license.dto';
+import { UpdateLicenseDto } from './dto/update-license.dto';
+
+const RENEWAL_WARNING_DAYS = 30;
 
 @Injectable()
 export class LicensesService {
   constructor(
     @InjectRepository(License)
     private readonly licenseRepo: Repository<License>,
+    @InjectRepository(LicenseSeatAssignment)
+    private readonly seatRepo: Repository<LicenseSeatAssignment>,
   ) {}
 
+  private withRenewalFlag(license: License) {
+    let renewsSoon = false;
+    if (license.expiryDate) {
+      const days = Math.ceil(
+        (new Date(license.expiryDate).getTime() - Date.now()) /
+          (1000 * 60 * 60 * 24),
+      );
+      renewsSoon = days >= 0 && days <= RENEWAL_WARNING_DAYS;
+    }
+    return { ...license, renewsSoon };
+  }
+
   async findAll() {
-    return this.licenseRepo.find();
+    const licenses = await this.licenseRepo.find();
+    return licenses.map((l) => this.withRenewalFlag(l));
   }
 
   async findById(id: string) {
     const lic = await this.licenseRepo.findOne({ where: { id } });
     if (!lic) throw new NotFoundException(`License ${id} not found`);
-    return lic;
+    return this.withRenewalFlag(lic);
   }
 
-  async create(dto: Partial<License>) {
+  async create(dto: CreateLicenseDto) {
     const lic = this.licenseRepo.create(dto);
-    return this.licenseRepo.save(lic);
+    const saved = await this.licenseRepo.save(lic);
+    return this.findById(saved.id);
+  }
+
+  async update(id: string, dto: UpdateLicenseDto) {
+    const lic = await this.licenseRepo.findOne({ where: { id } });
+    if (!lic) throw new NotFoundException(`License ${id} not found`);
+    if (dto.seatsTotal !== undefined && dto.seatsTotal < lic.seatsUsed) {
+      throw new BadRequestException(
+        `Cannot reduce total seats below the ${lic.seatsUsed} seat(s) currently assigned`,
+      );
+    }
+    Object.assign(lic, dto);
+    await this.licenseRepo.save(lic);
+    return this.findById(id);
+  }
+
+  async delete(id: string) {
+    const lic = await this.licenseRepo.findOne({ where: { id } });
+    if (!lic) throw new NotFoundException(`License ${id} not found`);
+    return this.licenseRepo.remove(lic);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async assign(id: string, _userIdOrAssetId: string) {
-    const lic = await this.findById(id);
+  /** Returns the plaintext license key — only ever called from the explicit reveal action. */
+  async revealKey(id: string): Promise<{ licenseKey: string }> {
+    const lic = await this.licenseRepo
+      .createQueryBuilder('license')
+      .addSelect('license.licenseKey')
+      .where('license.id = :id', { id })
+      .getOne();
+    if (!lic) throw new NotFoundException(`License ${id} not found`);
+    return { licenseKey: lic.licenseKey };
+  }
+
+  async getAssignments(licenseId: string) {
+    await this.findById(licenseId);
+    return this.seatRepo.find({
+      where: { licenseId, unassignedAt: IsNull() },
+      order: { assignedAt: 'ASC' },
+    });
+  }
+
+  async assign(licenseId: string, dto: { userId: string }) {
+    const lic = await this.licenseRepo.findOne({ where: { id: licenseId } });
+    if (!lic) throw new NotFoundException(`License ${licenseId} not found`);
     if (lic.seatsUsed >= lic.seatsTotal) {
       throw new ConflictException(
         'No available seats remaining for this license',
       );
     }
+
+    const existing = await this.seatRepo.findOne({
+      where: { licenseId, userId: dto.userId, unassignedAt: IsNull() },
+    });
+    if (existing) {
+      throw new ConflictException(
+        'This user already holds a seat for this license',
+      );
+    }
+
+    const assignment = this.seatRepo.create({ licenseId, userId: dto.userId });
+    await this.seatRepo.save(assignment);
     lic.seatsUsed += 1;
-    return this.licenseRepo.save(lic);
+    await this.licenseRepo.save(lic);
+    return this.findById(licenseId);
+  }
+
+  async unassign(licenseId: string, assignmentId: string) {
+    const lic = await this.licenseRepo.findOne({ where: { id: licenseId } });
+    if (!lic) throw new NotFoundException(`License ${licenseId} not found`);
+
+    const assignment = await this.seatRepo.findOne({
+      where: { id: assignmentId, licenseId, unassignedAt: IsNull() },
+    });
+    if (!assignment)
+      throw new NotFoundException('Active seat assignment not found');
+
+    assignment.unassignedAt = new Date();
+    await this.seatRepo.save(assignment);
+    lic.seatsUsed = Math.max(0, lic.seatsUsed - 1);
+    await this.licenseRepo.save(lic);
+    return this.findById(licenseId);
   }
 }
diff --git a/backend/src/locations/dto/create-location.dto.ts b/backend/src/locations/dto/create-location.dto.ts
new file mode 100644
index 000000000..7bf8db57b
--- /dev/null
+++ b/backend/src/locations/dto/create-location.dto.ts
@@ -0,0 +1,26 @@
+import { IsEnum, IsOptional, IsString } from 'class-validator';
+import { LocationType } from '../entities/location.entity';
+
+export class CreateLocationDto {
+  @IsString()
+  name: string;
+
+  @IsString()
+  code: string;
+
+  @IsOptional()
+  @IsEnum(LocationType)
+  type?: LocationType;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsOptional()
+  @IsString()
+  parentLocationId?: string;
+
+  @IsOptional()
+  @IsString()
+  branchId?: string;
+}
diff --git a/backend/src/locations/dto/update-location.dto.ts b/backend/src/locations/dto/update-location.dto.ts
new file mode 100644
index 000000000..27875b263
--- /dev/null
+++ b/backend/src/locations/dto/update-location.dto.ts
@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateLocationDto } from './create-location.dto';
+
+export class UpdateLocationDto extends PartialType(CreateLocationDto) {}
diff --git a/backend/src/locations/locations.controller.ts b/backend/src/locations/locations.controller.ts
index c36655f9d..da8918c50 100644
--- a/backend/src/locations/locations.controller.ts
+++ b/backend/src/locations/locations.controller.ts
@@ -14,6 +14,8 @@ import {
   ApiResponse,
 } from '@nestjs/swagger';
 import { LocationsService } from './locations.service';
+import { CreateLocationDto } from './dto/create-location.dto';
+import { UpdateLocationDto } from './dto/update-location.dto';
 
 @ApiTags('locations')
 @ApiBearerAuth('JWT-auth')
@@ -22,7 +24,9 @@ export class LocationsController {
   constructor(private readonly locationsService: LocationsService) {}
 
   @Get()
-  @ApiOperation({ summary: 'List all locations' })
+  @ApiOperation({
+    summary: 'List all locations with per-node and rolled-up asset counts',
+  })
   @ApiResponse({ status: 200, description: 'List of locations' })
   findAll() {
     return this.locationsService.findAll();
@@ -31,7 +35,7 @@ export class LocationsController {
   @Post()
   @ApiOperation({ summary: 'Create a location' })
   @ApiResponse({ status: 201, description: 'Location created' })
-  create(@Body() dto: any) {
+  create(@Body() dto: CreateLocationDto) {
     return this.locationsService.create(dto);
   }
 
@@ -44,14 +48,16 @@ export class LocationsController {
   }
 
   @Patch(':id')
-  @ApiOperation({ summary: 'Update a location' })
+  @ApiOperation({ summary: 'Update or move a location' })
   @ApiResponse({ status: 200, description: 'Location updated' })
-  update(@Param('id') id: string, @Body() dto: any) {
+  update(@Param('id') id: string, @Body() dto: UpdateLocationDto) {
     return this.locationsService.update(id, dto);
   }
 
   @Delete(':id')
-  @ApiOperation({ summary: 'Delete a location' })
+  @ApiOperation({
+    summary: 'Delete a location (blocked if children or assets exist)',
+  })
   @ApiResponse({ status: 200, description: 'Location deleted' })
   delete(@Param('id') id: string) {
     return this.locationsService.delete(id);
diff --git a/backend/src/locations/locations.module.ts b/backend/src/locations/locations.module.ts
index 8f2955e3f..aed12f253 100644
--- a/backend/src/locations/locations.module.ts
+++ b/backend/src/locations/locations.module.ts
@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Location } from './entities/location.entity';
+import { Asset } from '../assets/entities/asset.entity';
 import { LocationsService } from './locations.service';
 import { LocationsController } from './locations.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Location])],
+  imports: [TypeOrmModule.forFeature([Location, Asset])],
   providers: [LocationsService],
   controllers: [LocationsController],
   exports: [LocationsService],
diff --git a/backend/src/locations/locations.service.ts b/backend/src/locations/locations.service.ts
index 8b03ee248..46ee77fd0 100644
--- a/backend/src/locations/locations.service.ts
+++ b/backend/src/locations/locations.service.ts
@@ -2,20 +2,65 @@ import {
   Injectable,
   NotFoundException,
   BadRequestException,
+  ConflictException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Location } from './entities/location.entity';
+import { Asset } from '../assets/entities/asset.entity';
+import { CreateLocationDto } from './dto/create-location.dto';
+import { UpdateLocationDto } from './dto/update-location.dto';
+
+export interface LocationWithCounts extends Location {
+  assetCount: number;
+  totalAssetCount: number;
+}
 
 @Injectable()
 export class LocationsService {
   constructor(
     @InjectRepository(Location)
     private readonly locationRepo: Repository<Location>,
+    @InjectRepository(Asset)
+    private readonly assetRepo: Repository<Asset>,
   ) {}
 
-  async findAll() {
-    return this.locationRepo.find();
+  async findAll(): Promise<LocationWithCounts[]> {
+    const locations = await this.locationRepo.find();
+    const counts = await this.assetRepo
+      .createQueryBuilder('asset')
+      .select('asset.locationId', 'locationId')
+      .addSelect('COUNT(*)', 'count')
+      .where('asset.locationId IS NOT NULL')
+      .groupBy('asset.locationId')
+      .getRawMany<{ locationId: string; count: string }>();
+
+    const directCounts = new Map<string, number>(
+      counts.map((c) => [c.locationId, Number(c.count)]),
+    );
+
+    const childrenByParent = new Map<string, string[]>();
+    for (const loc of locations) {
+      const key = loc.parentLocationId ?? '';
+      childrenByParent.set(key, [...(childrenByParent.get(key) ?? []), loc.id]);
+    }
+
+    const totalCache = new Map<string, number>();
+    const computeTotal = (id: string): number => {
+      if (totalCache.has(id)) return totalCache.get(id) as number;
+      const own = directCounts.get(id) ?? 0;
+      const children = childrenByParent.get(id) ?? [];
+      const total =
+        own + children.reduce((sum, childId) => sum + computeTotal(childId), 0);
+      totalCache.set(id, total);
+      return total;
+    };
+
+    return locations.map((loc) => ({
+      ...loc,
+      assetCount: directCounts.get(loc.id) ?? 0,
+      totalAssetCount: computeTotal(loc.id),
+    }));
   }
 
   async findById(id: string) {
@@ -24,15 +69,21 @@ export class LocationsService {
     return loc;
   }
 
-  async create(dto: Partial<Location>) {
+  async create(dto: CreateLocationDto) {
+    if (dto.parentLocationId) {
+      await this.findById(dto.parentLocationId);
+    }
     const loc = this.locationRepo.create(dto);
     return this.locationRepo.save(loc);
   }
 
-  async update(id: string, dto: Partial<Location>) {
+  async update(id: string, dto: UpdateLocationDto) {
     const loc = await this.findById(id);
-    if (dto.parentLocationId && dto.parentLocationId === id) {
-      throw new BadRequestException('A location cannot be its own parent');
+    if (dto.parentLocationId) {
+      if (dto.parentLocationId === id) {
+        throw new BadRequestException('A location cannot be its own parent');
+      }
+      await this.assertNotDescendant(id, dto.parentLocationId);
     }
     Object.assign(loc, dto);
     return this.locationRepo.save(loc);
@@ -40,6 +91,44 @@ export class LocationsService {
 
   async delete(id: string) {
     const loc = await this.findById(id);
+
+    const childCount = await this.locationRepo.count({
+      where: { parentLocationId: id },
+    });
+    if (childCount > 0) {
+      throw new ConflictException(
+        'This location has child locations. Delete or move them before deleting this location.',
+      );
+    }
+
+    const assetCount = await this.assetRepo.count({
+      where: { locationId: id },
+    });
+    if (assetCount > 0) {
+      throw new ConflictException(
+        `This location still has ${assetCount} asset(s) assigned to it. Reassign them before deleting.`,
+      );
+    }
+
     return this.locationRepo.remove(loc);
   }
+
+  /** Prevent moving a location underneath one of its own descendants. */
+  private async assertNotDescendant(id: string, candidateParentId: string) {
+    let current: string | undefined = candidateParentId;
+    const visited = new Set<string>();
+    while (current) {
+      if (current === id) {
+        throw new BadRequestException(
+          'Cannot move a location under its own descendant',
+        );
+      }
+      if (visited.has(current)) break;
+      visited.add(current);
+      const parent: Location | null = await this.locationRepo.findOne({
+        where: { id: current },
+      });
+      current = parent?.parentLocationId;
+    }
+  }
 }
diff --git a/backend/src/maintenance/asset-maintenance.controller.ts b/backend/src/maintenance/asset-maintenance.controller.ts
new file mode 100644
index 000000000..424338faa
--- /dev/null
+++ b/backend/src/maintenance/asset-maintenance.controller.ts
@@ -0,0 +1,34 @@
+import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { MaintenanceService } from './maintenance.service';
+import { CreateMaintenanceRecordDto } from './dto/create-maintenance-record.dto';
+
+@ApiTags('assets')
+@Controller('assets/:id/maintenance')
+export class AssetMaintenanceController {
+  constructor(private readonly maintenanceService: MaintenanceService) {}
+
+  @Get()
+  @ApiOperation({ summary: "Get an asset's maintenance history" })
+  findForAsset(@Param('id') assetId: string) {
+    return this.maintenanceService.findAll({ assetId });
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Schedule maintenance for an asset' })
+  create(
+    @Param('id') assetId: string,
+    @Body() dto: CreateMaintenanceRecordDto,
+  ) {
+    return this.maintenanceService.create(dto, assetId);
+  }
+
+  @Patch(':maintenanceId')
+  @ApiOperation({ summary: "Update an asset's maintenance record status" })
+  updateStatus(
+    @Param('maintenanceId') maintenanceId: string,
+    @Body('status') status: string,
+  ) {
+    return this.maintenanceService.updateStatus(maintenanceId, status);
+  }
+}
diff --git a/backend/src/maintenance/dto/create-maintenance-record.dto.ts b/backend/src/maintenance/dto/create-maintenance-record.dto.ts
new file mode 100644
index 000000000..635acfda6
--- /dev/null
+++ b/backend/src/maintenance/dto/create-maintenance-record.dto.ts
@@ -0,0 +1,45 @@
+import {
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+} from 'class-validator';
+import { MaintenanceType } from '../entities/maintenance-record.entity';
+
+export class CreateMaintenanceRecordDto {
+  @IsOptional()
+  @IsString()
+  assetId?: string;
+
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(MaintenanceType)
+  type?: MaintenanceType;
+
+  @IsOptional()
+  @IsString()
+  vendorId?: string;
+
+  @IsOptional()
+  @IsInt()
+  cost?: number;
+
+  @IsOptional()
+  @IsString()
+  currency?: string;
+
+  @IsDateString()
+  scheduledDate: string;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/backend/src/maintenance/dto/update-maintenance-record.dto.ts b/backend/src/maintenance/dto/update-maintenance-record.dto.ts
new file mode 100644
index 000000000..30b97a136
--- /dev/null
+++ b/backend/src/maintenance/dto/update-maintenance-record.dto.ts
@@ -0,0 +1,16 @@
+import { PartialType, OmitType } from '@nestjs/mapped-types';
+import { IsDateString, IsEnum, IsOptional } from 'class-validator';
+import { CreateMaintenanceRecordDto } from './create-maintenance-record.dto';
+import { MaintenanceStatus } from '../entities/maintenance-record.entity';
+
+export class UpdateMaintenanceRecordDto extends PartialType(
+  OmitType(CreateMaintenanceRecordDto, ['assetId'] as const),
+) {
+  @IsOptional()
+  @IsEnum(MaintenanceStatus)
+  status?: MaintenanceStatus;
+
+  @IsOptional()
+  @IsDateString()
+  completedDate?: string;
+}
diff --git a/backend/src/maintenance/entities/maintenance-record.entity.ts b/backend/src/maintenance/entities/maintenance-record.entity.ts
index 4990e2092..2a4aed754 100644
--- a/backend/src/maintenance/entities/maintenance-record.entity.ts
+++ b/backend/src/maintenance/entities/maintenance-record.entity.ts
@@ -13,6 +13,12 @@ export enum MaintenanceStatus {
   CANCELLED = 'CANCELLED',
 }
 
+export enum MaintenanceType {
+  PREVENTIVE = 'PREVENTIVE',
+  CORRECTIVE = 'CORRECTIVE',
+  SCHEDULED = 'SCHEDULED',
+}
+
 @Entity('maintenance_records')
 export class MaintenanceRecord {
   @PrimaryGeneratedColumn('uuid')
@@ -27,6 +33,13 @@ export class MaintenanceRecord {
   @Column({ nullable: true })
   description?: string;
 
+  @Column({
+    type: 'enum',
+    enum: MaintenanceType,
+    default: MaintenanceType.SCHEDULED,
+  })
+  type: MaintenanceType;
+
   @Column({
     type: 'enum',
     enum: MaintenanceStatus,
@@ -37,6 +50,9 @@ export class MaintenanceRecord {
   @Column({ nullable: true })
   vendorId?: string;
 
+  @Column({ nullable: true })
+  performedByUserId?: string;
+
   @Column({ type: 'integer', default: 0 })
   cost: number;
 
@@ -49,6 +65,9 @@ export class MaintenanceRecord {
   @Column({ nullable: true })
   completedDate?: Date;
 
+  @Column({ nullable: true })
+  notes?: string;
+
   @CreateDateColumn()
   createdAt: Date;
 
diff --git a/backend/src/maintenance/maintenance.controller.ts b/backend/src/maintenance/maintenance.controller.ts
index 936b272a0..b9de50643 100644
--- a/backend/src/maintenance/maintenance.controller.ts
+++ b/backend/src/maintenance/maintenance.controller.ts
@@ -1,4 +1,12 @@
-import { Controller, Get, Post, Patch, Body, Param } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Body,
+  Param,
+  Query,
+} from '@nestjs/common';
 import {
   ApiTags,
   ApiOperation,
@@ -6,6 +14,8 @@ import {
   ApiResponse,
 } from '@nestjs/swagger';
 import { MaintenanceService } from './maintenance.service';
+import { CreateMaintenanceRecordDto } from './dto/create-maintenance-record.dto';
+import { UpdateMaintenanceRecordDto } from './dto/update-maintenance-record.dto';
 
 @ApiTags('maintenance')
 @ApiBearerAuth('JWT-auth')
@@ -14,16 +24,32 @@ export class MaintenanceController {
   constructor(private readonly maintenanceService: MaintenanceService) {}
 
   @Get()
-  @ApiOperation({ summary: 'List all maintenance records' })
+  @ApiOperation({
+    summary: 'List all maintenance records across assets, with filters',
+  })
   @ApiResponse({ status: 200, description: 'List of maintenance records' })
-  findAll() {
-    return this.maintenanceService.findAll();
+  findAll(
+    @Query('assetId') assetId?: string,
+    @Query('status') status?: string,
+    @Query('type') type?: string,
+    @Query('departmentId') departmentId?: string,
+    @Query('from') from?: string,
+    @Query('to') to?: string,
+  ) {
+    return this.maintenanceService.findAll({
+      assetId,
+      status,
+      type,
+      departmentId,
+      from,
+      to,
+    });
   }
 
   @Post()
   @ApiOperation({ summary: 'Create a maintenance record' })
   @ApiResponse({ status: 201, description: 'Maintenance record created' })
-  create(@Body() dto: any) {
+  create(@Body() dto: CreateMaintenanceRecordDto) {
     return this.maintenanceService.create(dto);
   }
 
@@ -38,7 +64,7 @@ export class MaintenanceController {
   @Patch(':id')
   @ApiOperation({ summary: 'Update a maintenance record' })
   @ApiResponse({ status: 200, description: 'Maintenance record updated' })
-  update(@Param('id') id: string, @Body() dto: any) {
+  update(@Param('id') id: string, @Body() dto: UpdateMaintenanceRecordDto) {
     return this.maintenanceService.update(id, dto);
   }
 }
diff --git a/backend/src/maintenance/maintenance.module.ts b/backend/src/maintenance/maintenance.module.ts
index 7d4439644..3acbe09bb 100644
--- a/backend/src/maintenance/maintenance.module.ts
+++ b/backend/src/maintenance/maintenance.module.ts
@@ -3,11 +3,12 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { MaintenanceRecord } from './entities/maintenance-record.entity';
 import { MaintenanceService } from './maintenance.service';
 import { MaintenanceController } from './maintenance.controller';
+import { AssetMaintenanceController } from './asset-maintenance.controller';
 
 @Module({
   imports: [TypeOrmModule.forFeature([MaintenanceRecord])],
   providers: [MaintenanceService],
-  controllers: [MaintenanceController],
+  controllers: [MaintenanceController, AssetMaintenanceController],
   exports: [MaintenanceService],
 })
 export class MaintenanceModule {}
diff --git a/backend/src/maintenance/maintenance.service.ts b/backend/src/maintenance/maintenance.service.ts
index bf4cfd83e..35923ea54 100644
--- a/backend/src/maintenance/maintenance.service.ts
+++ b/backend/src/maintenance/maintenance.service.ts
@@ -1,7 +1,22 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { MaintenanceRecord } from './entities/maintenance-record.entity';
+import { CreateMaintenanceRecordDto } from './dto/create-maintenance-record.dto';
+import { UpdateMaintenanceRecordDto } from './dto/update-maintenance-record.dto';
+
+export interface MaintenanceQuery {
+  assetId?: string;
+  status?: string;
+  type?: string;
+  departmentId?: string;
+  from?: string;
+  to?: string;
+}
 
 @Injectable()
 export class MaintenanceService {
@@ -10,8 +25,26 @@ export class MaintenanceService {
     private readonly maintenanceRepo: Repository<MaintenanceRecord>,
   ) {}
 
-  async findAll() {
-    return this.maintenanceRepo.find();
+  async findAll(query?: MaintenanceQuery) {
+    const qb = this.maintenanceRepo.createQueryBuilder('record');
+
+    if (query?.departmentId) {
+      qb.innerJoin('assets', 'asset', 'asset.id = record.assetId').andWhere(
+        'asset.departmentId = :departmentId',
+        { departmentId: query.departmentId },
+      );
+    }
+    if (query?.assetId)
+      qb.andWhere('record.assetId = :assetId', { assetId: query.assetId });
+    if (query?.status)
+      qb.andWhere('record.status = :status', { status: query.status });
+    if (query?.type) qb.andWhere('record.type = :type', { type: query.type });
+    if (query?.from)
+      qb.andWhere('record.scheduledDate >= :from', { from: query.from });
+    if (query?.to) qb.andWhere('record.scheduledDate <= :to', { to: query.to });
+
+    qb.orderBy('record.scheduledDate', 'ASC');
+    return qb.getMany();
   }
 
   async findById(id: string) {
@@ -21,14 +54,40 @@ export class MaintenanceService {
     return record;
   }
 
-  async create(dto: Partial<MaintenanceRecord>) {
-    const record = this.maintenanceRepo.create(dto);
+  async create(dto: CreateMaintenanceRecordDto, assetIdFromParam?: string) {
+    const assetId = assetIdFromParam ?? dto.assetId;
+    if (!assetId) throw new BadRequestException('assetId is required');
+
+    const record = this.maintenanceRepo.create({
+      ...dto,
+      assetId,
+      title: dto.title || dto.description || 'Maintenance',
+      scheduledDate: dto.scheduledDate
+        ? new Date(dto.scheduledDate)
+        : undefined,
+    });
+    return this.maintenanceRepo.save(record);
+  }
+
+  async update(id: string, dto: UpdateMaintenanceRecordDto) {
+    const record = await this.findById(id);
+    Object.assign(record, dto, {
+      scheduledDate: dto.scheduledDate
+        ? new Date(dto.scheduledDate)
+        : record.scheduledDate,
+      completedDate: dto.completedDate
+        ? new Date(dto.completedDate)
+        : record.completedDate,
+    });
     return this.maintenanceRepo.save(record);
   }
 
-  async update(id: string, dto: Partial<MaintenanceRecord>) {
+  async updateStatus(id: string, status: string) {
     const record = await this.findById(id);
-    Object.assign(record, dto);
+    record.status = status as MaintenanceRecord['status'];
+    if (status === 'COMPLETED' && !record.completedDate) {
+      record.completedDate = new Date();
+    }
     return this.maintenanceRepo.save(record);
   }
 }
diff --git a/frontend/app/(dashboard)/assets/page.tsx b/frontend/app/(dashboard)/assets/page.tsx
index fa8049607..f990c66f5 100644
--- a/frontend/app/(dashboard)/assets/page.tsx
+++ b/frontend/app/(dashboard)/assets/page.tsx
@@ -1,27 +1,34 @@
 "use client";
 
 import { useState } from "react";
-import { useRouter } from "next/navigation";
-import { Plus, Search, SlidersHorizontal } from "lucide-react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { Plus, Search, SlidersHorizontal, MapPin, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { StatusBadge } from "@/components/assets/status-badge";
 import { ConditionBadge } from "@/components/assets/condition-badge";
 import { CreateAssetModal } from "@/components/assets/create-asset-modal";
 import { useAssets } from "@/lib/query/hooks/useAssets";
+import { useLocations } from "@/lib/query/hooks/useLocations";
 import { AssetStatus, AssetCondition } from "@/lib/query/types/asset";
 
 const STATUS_OPTIONS = ["All", ...Object.values(AssetStatus)];
 
 export default function AssetsPage() {
   const router = useRouter();
+  const searchParams = useSearchParams();
   const [showModal, setShowModal] = useState(false);
   const [search, setSearch] = useState("");
   const [status, setStatus] = useState("");
   const [page, setPage] = useState(1);
+  const [locationId, setLocationId] = useState(searchParams.get("locationId") || "");
+
+  const { data: locations = [] } = useLocations();
+  const activeLocation = locations.find((l) => l.id === locationId);
 
   const { data, isLoading, refetch } = useAssets({
     search: search || undefined,
     status: (status as AssetStatus) || undefined,
+    locationId: locationId || undefined,
     page,
     limit: 20,
   });
@@ -96,6 +103,26 @@ export default function AssetsPage() {
         </div>
       </div>
 
+      {activeLocation && (
+        <div className="flex items-center gap-2 mb-4">
+          <span className="inline-flex items-center gap-1.5 pl-2.5 pr-1.5 py-1 rounded-full bg-gray-100 text-xs font-medium text-gray-700">
+            <MapPin size={12} />
+            {activeLocation.name}
+            <button
+              onClick={() => {
+                setLocationId("");
+                setPage(1);
+                router.replace("/assets");
+              }}
+              aria-label="Clear location filter"
+              className="p-0.5 hover:bg-gray-200 rounded-full"
+            >
+              <X size={12} />
+            </button>
+          </span>
+        </div>
+      )}
+
       {/* Table */}
       <div className="bg-white rounded-xl border border-gray-200 overflow-hidden">
         <div className="overflow-x-auto">
diff --git a/frontend/app/(dashboard)/audits/[id]/page.tsx b/frontend/app/(dashboard)/audits/[id]/page.tsx
new file mode 100644
index 000000000..2a0e3575d
--- /dev/null
+++ b/frontend/app/(dashboard)/audits/[id]/page.tsx
@@ -0,0 +1,242 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { useParams, useRouter } from "next/navigation";
+import { ArrowLeft, Search, CheckCircle2, Lock } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { ConfirmDialog } from "@/components/ui/confirm-dialog";
+import { CsvExportButton } from "@/components/ui/csv";
+import {
+  useAuditSession,
+  useRecordAuditItem,
+  useCompleteAuditSession,
+} from "@/lib/query/hooks/useAudits";
+import { useAssets } from "@/lib/query/hooks/useAssets";
+import { useLocations } from "@/lib/query/hooks/useLocations";
+import { AuditItem, AuditItemResult } from "@/lib/api/audits";
+
+const RESULT_OPTIONS: { value: AuditItemResult; label: string; className: string }[] = [
+  { value: "FOUND", label: "Found", className: "bg-green-100 text-green-700 border-green-200" },
+  { value: "MISSING", label: "Missing", className: "bg-red-100 text-red-700 border-red-200" },
+  { value: "WRONG_LOCATION", label: "Wrong Location", className: "bg-amber-100 text-amber-700 border-amber-200" },
+  { value: "DAMAGED", label: "Damaged", className: "bg-orange-100 text-orange-700 border-orange-200" },
+];
+
+const resultLabel: Record<AuditItemResult, string> = {
+  PENDING: "Pending",
+  FOUND: "Found",
+  MISSING: "Missing",
+  WRONG_LOCATION: "Wrong Location",
+  DAMAGED: "Damaged",
+};
+
+export default function AuditSessionPage() {
+  const params = useParams<{ id: string }>();
+  const router = useRouter();
+  const { data: session, isLoading } = useAuditSession(params.id);
+  const { data: assetsPage } = useAssets({ limit: 500 });
+  const { data: locations = [] } = useLocations();
+  const recordItem = useRecordAuditItem(params.id);
+  const completeSession = useCompleteAuditSession(params.id);
+
+  const [search, setSearch] = useState("");
+  const [showCompleteConfirm, setShowCompleteConfirm] = useState(false);
+  const [noteDrafts, setNoteDrafts] = useState<Record<string, string>>({});
+
+  const assetMap = useMemo(() => {
+    const map = new Map<string, string>();
+    (assetsPage?.data ?? []).forEach((a) => map.set(a.id, a.name));
+    return map;
+  }, [assetsPage]);
+
+  const locationMap = useMemo(() => {
+    const map = new Map<string, string>();
+    locations.forEach((l) => map.set(l.id, l.name));
+    return map;
+  }, [locations]);
+
+  if (isLoading || !session) {
+    return <div className="text-sm text-gray-400 text-center py-16">Loading audit session...</div>;
+  }
+
+  const isCompleted = session.status === "COMPLETED";
+  const filteredItems = session.items.filter((item) => {
+    if (!search.trim()) return true;
+    const assetName = assetMap.get(item.assetId) || "";
+    return assetName.toLowerCase().includes(search.trim().toLowerCase());
+  });
+
+  const discrepancies = session.items.filter((i) => i.result !== "PENDING" && i.result !== "FOUND");
+
+  const handleRecord = (item: AuditItem, result: AuditItemResult) => {
+    recordItem.mutate({
+      itemId: item.id,
+      data: { result, note: noteDrafts[item.id] ?? item.note ?? undefined },
+    });
+  };
+
+  return (
+    <div>
+      <button
+        onClick={() => router.push("/audits")}
+        className="flex items-center gap-1.5 text-sm text-gray-500 hover:text-gray-900 mb-4"
+      >
+        <ArrowLeft size={15} />
+        Back to audits
+      </button>
+
+      <div className="flex items-center justify-between mb-2">
+        <h1 className="text-2xl font-bold text-gray-900">{session.name}</h1>
+        <div className="flex items-center gap-2">
+          {isCompleted && (
+            <span className="inline-flex items-center gap-1 text-xs font-medium text-gray-500">
+              <Lock size={12} />
+              Immutable
+            </span>
+          )}
+          <span
+            className={`inline-flex items-center px-2 py-0.5 rounded text-xs font-medium ${
+              isCompleted ? "bg-green-100 text-green-700" : "bg-blue-100 text-blue-700"
+            }`}
+          >
+            {session.status.replace("_", " ")}
+          </span>
+        </div>
+      </div>
+
+      <div className="flex items-center gap-2 mb-6">
+        <div className="flex-1 h-2 bg-gray-100 rounded-full overflow-hidden max-w-md">
+          <div className="h-full bg-gray-900 rounded-full" style={{ width: `${session.progressPercent}%` }} />
+        </div>
+        <span className="text-sm text-gray-500">
+          {session.checkedItems}/{session.totalItems} checked ({session.progressPercent}%)
+        </span>
+      </div>
+
+      {isCompleted && (
+        <div className="bg-white rounded-xl border border-gray-200 p-4 mb-6">
+          <div className="flex items-center justify-between mb-3">
+            <div>
+              <h2 className="text-sm font-semibold text-gray-900">Discrepancy Report</h2>
+              <p className="text-xs text-gray-400 mt-0.5">
+                {discrepancies.length} item{discrepancies.length !== 1 ? "s" : ""} not matching expectations
+              </p>
+            </div>
+            <CsvExportButton
+              filename={`audit-${session.id}-discrepancies`}
+              rows={discrepancies.map((d) => ({
+                asset: assetMap.get(d.assetId) || d.assetId,
+                expectedLocation: d.expectedLocationId ? locationMap.get(d.expectedLocationId) || "" : "",
+                result: resultLabel[d.result],
+                note: d.note || "",
+                checkedAt: d.checkedAt || "",
+              }))}
+              columns={[
+                { key: "asset", label: "Asset" },
+                { key: "expectedLocation", label: "Expected Location" },
+                { key: "result", label: "Result" },
+                { key: "note", label: "Note" },
+                { key: "checkedAt", label: "Checked At" },
+              ]}
+            />
+          </div>
+
+          {discrepancies.length === 0 ? (
+            <p className="text-sm text-gray-500 flex items-center gap-1.5">
+              <CheckCircle2 size={15} className="text-green-500" />
+              No discrepancies — every asset was found where expected.
+            </p>
+          ) : (
+            <ul className="divide-y divide-gray-100">
+              {discrepancies.map((d) => (
+                <li key={d.id} className="py-2 flex items-center justify-between text-sm">
+                  <span className="font-medium text-gray-900">{assetMap.get(d.assetId) || d.assetId}</span>
+                  <span className="text-gray-500">{resultLabel[d.result]}{d.note ? ` — ${d.note}` : ""}</span>
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      )}
+
+      {!isCompleted && (
+        <div className="flex items-center justify-between mb-4">
+          <div className="relative max-w-sm flex-1">
+            <Search size={15} className="absolute left-3 top-1/2 -translate-y-1/2 text-gray-400" />
+            <input
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+              placeholder="Search assets to verify..."
+              className="w-full pl-9 pr-3 py-2 text-sm border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-gray-900"
+            />
+          </div>
+          <Button size="sm" onClick={() => setShowCompleteConfirm(true)}>
+            Complete Audit
+          </Button>
+        </div>
+      )}
+
+      <div className="bg-white rounded-xl border border-gray-200 divide-y divide-gray-100">
+        {filteredItems.map((item) => (
+          <div key={item.id} className="p-4">
+            <div className="flex items-center justify-between mb-2">
+              <div>
+                <p className="font-medium text-gray-900">{assetMap.get(item.assetId) || item.assetId}</p>
+                <p className="text-xs text-gray-400">
+                  Expected: {item.expectedLocationId ? locationMap.get(item.expectedLocationId) || "—" : "No location set"}
+                </p>
+              </div>
+              <span className="text-xs font-medium text-gray-500">{resultLabel[item.result]}</span>
+            </div>
+
+            {!isCompleted && (
+              <div className="flex flex-wrap items-center gap-2 mt-2">
+                {RESULT_OPTIONS.map((opt) => (
+                  <button
+                    key={opt.value}
+                    onClick={() => handleRecord(item, opt.value)}
+                    disabled={recordItem.isPending}
+                    className={`px-2.5 py-1 rounded-full text-xs font-medium border transition-opacity ${opt.className} ${
+                      item.result === opt.value ? "opacity-100 ring-1 ring-offset-1 ring-current" : "opacity-60 hover:opacity-100"
+                    }`}
+                  >
+                    {opt.label}
+                  </button>
+                ))}
+                <input
+                  placeholder="Add a note..."
+                  value={noteDrafts[item.id] ?? item.note ?? ""}
+                  onChange={(e) => setNoteDrafts((prev) => ({ ...prev, [item.id]: e.target.value }))}
+                  onBlur={() => {
+                    if (item.result !== "PENDING") handleRecord(item, item.result);
+                  }}
+                  className="flex-1 min-w-[140px] text-xs border border-gray-200 rounded-lg px-2.5 py-1.5 focus:outline-none focus:ring-2 focus:ring-gray-900"
+                />
+              </div>
+            )}
+            {isCompleted && item.note && (
+              <p className="text-xs text-gray-500 mt-1">{item.note}</p>
+            )}
+          </div>
+        ))}
+        {filteredItems.length === 0 && (
+          <p className="text-sm text-gray-400 text-center py-10">No assets match your search.</p>
+        )}
+      </div>
+
+      {showCompleteConfirm && (
+        <ConfirmDialog
+          title="Complete this audit?"
+          message="Once completed, results become read-only and cannot be edited. Any unchecked assets will stay unresolved in the discrepancy report."
+          confirmLabel="Complete Audit"
+          onConfirm={async () => {
+            await completeSession.mutateAsync();
+            setShowCompleteConfirm(false);
+          }}
+          onCancel={() => setShowCompleteConfirm(false)}
+          loading={completeSession.isPending}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/frontend/app/(dashboard)/audits/page.tsx b/frontend/app/(dashboard)/audits/page.tsx
new file mode 100644
index 000000000..fb462ecbe
--- /dev/null
+++ b/frontend/app/(dashboard)/audits/page.tsx
@@ -0,0 +1,198 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { ClipboardCheck, Plus, X } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useAuditSessions, useCreateAuditSession } from "@/lib/query/hooks/useAudits";
+import { useDepartmentsList } from "@/lib/query/hooks/useAssets";
+import { useLocations } from "@/lib/query/hooks/useLocations";
+import { AuditSessionStatus } from "@/lib/api/audits";
+
+const statusStyles: Record<AuditSessionStatus, string> = {
+  DRAFT: "bg-gray-100 text-gray-600",
+  IN_PROGRESS: "bg-blue-100 text-blue-700",
+  COMPLETED: "bg-green-100 text-green-700",
+};
+
+function errorMessage(err: unknown, fallback: string): string {
+  return (
+    (err as { response?: { data?: { message?: string } } })?.response?.data?.message || fallback
+  );
+}
+
+export default function AuditsPage() {
+  const router = useRouter();
+  const { data: sessions = [], isLoading } = useAuditSessions();
+  const [showWizard, setShowWizard] = useState(false);
+
+  return (
+    <div>
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-2xl font-bold text-gray-900">Audits / Stocktake</h1>
+          <p className="text-sm text-gray-500 mt-1">
+            Verify physical assets exist where the system says they do
+          </p>
+        </div>
+        <Button size="sm" onClick={() => setShowWizard(true)}>
+          <Plus size={15} className="mr-1" />
+          Start Audit
+        </Button>
+      </div>
+
+      {isLoading ? (
+        <div className="text-sm text-gray-400 text-center py-16">Loading audit sessions...</div>
+      ) : sessions.length === 0 ? (
+        <div className="text-center py-16 bg-white rounded-xl border border-gray-200">
+          <div className="flex justify-center mb-3">
+            <ClipboardCheck size={32} className="text-gray-300" />
+          </div>
+          <p className="text-sm font-medium text-gray-700">No audit sessions yet</p>
+          <p className="text-xs text-gray-400 mt-1">
+            Click &quot;Start Audit&quot; to run your first stocktake.
+          </p>
+        </div>
+      ) : (
+        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3">
+          {sessions.map((session) => (
+            <button
+              key={session.id}
+              onClick={() => router.push(`/audits/${session.id}`)}
+              className="text-left bg-white rounded-xl border border-gray-200 p-4 hover:border-gray-300 transition-colors"
+            >
+              <div className="flex items-center justify-between mb-2">
+                <p className="font-medium text-gray-900 truncate">{session.name}</p>
+                <span className={`inline-flex items-center px-2 py-0.5 rounded text-xs font-medium ${statusStyles[session.status]}`}>
+                  {session.status.replace("_", " ")}
+                </span>
+              </div>
+              <div className="flex items-center gap-2 mb-2">
+                <div className="flex-1 h-1.5 bg-gray-100 rounded-full overflow-hidden">
+                  <div className="h-full bg-gray-900 rounded-full" style={{ width: `${session.progressPercent}%` }} />
+                </div>
+                <span className="text-xs text-gray-500 flex-shrink-0">{session.progressPercent}%</span>
+              </div>
+              <div className="flex items-center justify-between text-xs text-gray-400">
+                <span>{session.checkedItems}/{session.totalItems} checked</span>
+                {session.discrepancyCount > 0 && (
+                  <span className="text-amber-600 font-medium">{session.discrepancyCount} discrepancies</span>
+                )}
+              </div>
+            </button>
+          ))}
+        </div>
+      )}
+
+      {showWizard && <StartAuditWizard onClose={() => setShowWizard(false)} />}
+    </div>
+  );
+}
+
+function StartAuditWizard({ onClose }: { onClose: () => void }) {
+  const router = useRouter();
+  const { data: departments = [] } = useDepartmentsList();
+  const { data: locations = [] } = useLocations();
+  const createSession = useCreateAuditSession();
+
+  const [name, setName] = useState("");
+  const [scopeType, setScopeType] = useState<"department" | "location">("department");
+  const [scopeId, setScopeId] = useState("");
+  const [error, setError] = useState("");
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!name.trim() || !scopeId) {
+      setError("Name and scope are required");
+      return;
+    }
+    setError("");
+    try {
+      const session = await createSession.mutateAsync({
+        name: name.trim(),
+        departmentId: scopeType === "department" ? scopeId : undefined,
+        locationId: scopeType === "location" ? scopeId : undefined,
+      });
+      router.push(`/audits/${session.id}`);
+    } catch (err) {
+      setError(errorMessage(err, "Failed to start audit session."));
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4">
+      <div className="absolute inset-0 bg-black/40" onClick={onClose} />
+      <div className="relative bg-white rounded-2xl shadow-xl w-full max-w-md max-h-[90vh] overflow-y-auto">
+        <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200 sticky top-0 bg-white">
+          <h2 className="text-base font-semibold text-gray-900">Start Audit</h2>
+          <button onClick={onClose} aria-label="Close" className="text-gray-400 hover:text-gray-600">
+            <X size={20} />
+          </button>
+        </div>
+
+        <form onSubmit={handleSubmit} className="px-6 py-5 space-y-4">
+          <Input
+            id="audit-name"
+            label="Audit Name *"
+            placeholder="e.g. Q3 2026 HQ Stocktake"
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+          />
+
+          <div className="flex gap-1 bg-gray-100 rounded-lg p-1 w-fit">
+            <button
+              type="button"
+              onClick={() => { setScopeType("department"); setScopeId(""); }}
+              className={`px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${
+                scopeType === "department" ? "bg-white text-gray-900 shadow-sm" : "text-gray-500"
+              }`}
+            >
+              By Department
+            </button>
+            <button
+              type="button"
+              onClick={() => { setScopeType("location"); setScopeId(""); }}
+              className={`px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${
+                scopeType === "location" ? "bg-white text-gray-900 shadow-sm" : "text-gray-500"
+              }`}
+            >
+              By Location
+            </button>
+          </div>
+
+          <div className="flex flex-col gap-1">
+            <label className="text-sm font-medium text-gray-700">
+              {scopeType === "department" ? "Department *" : "Location *"}
+            </label>
+            <select
+              value={scopeId}
+              onChange={(e) => setScopeId(e.target.value)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+            >
+              <option value="">Select {scopeType}</option>
+              {scopeType === "department"
+                ? departments.map((d) => <option key={d.id} value={d.id}>{d.name}</option>)
+                : locations.map((l) => <option key={l.id} value={l.id}>{l.name}</option>)}
+            </select>
+          </div>
+
+          <p className="text-xs text-gray-400">
+            The system will generate a checklist from every asset currently assigned to this scope.
+          </p>
+
+          {error && (
+            <p className="text-sm text-red-500 bg-red-50 border border-red-200 rounded-lg px-3 py-2">{error}</p>
+          )}
+
+          <div className="flex gap-3 pt-2">
+            <Button type="button" variant="outline" className="flex-1" onClick={onClose}>Cancel</Button>
+            <Button type="submit" className="flex-1" loading={createSession.isPending}>
+              Generate Checklist
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/app/(dashboard)/licenses/page.tsx b/frontend/app/(dashboard)/licenses/page.tsx
new file mode 100644
index 000000000..5469f069e
--- /dev/null
+++ b/frontend/app/(dashboard)/licenses/page.tsx
@@ -0,0 +1,481 @@
+"use client";
+
+import { useState } from "react";
+import { Plus, KeyRound, Eye, EyeOff, X, UserMinus, AlertTriangle } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { ConfirmDialog } from "@/components/ui/confirm-dialog";
+import {
+  useLicenses,
+  useCreateLicense,
+  useUpdateLicense,
+  useDeleteLicense,
+  useRevealLicenseKey,
+  useLicenseAssignments,
+  useAssignSeat,
+  useUnassignSeat,
+} from "@/lib/query/hooks/useLicenses";
+import { useUsers } from "@/lib/query/hooks/useAssets";
+import { License, LicenseType, BillingPeriod } from "@/lib/api/licenses";
+
+function errorMessage(err: unknown, fallback: string): string {
+  return (
+    (err as { response?: { data?: { message?: string } } })?.response?.data?.message || fallback
+  );
+}
+
+function formatDate(value?: string | null) {
+  if (!value) return "—";
+  return new Date(value).toLocaleDateString();
+}
+
+export default function LicensesPage() {
+  const { data: licenses = [], isLoading } = useLicenses();
+  const [formTarget, setFormTarget] = useState<{ mode: "create" | "edit"; license?: License } | null>(
+    null,
+  );
+  const [detailLicense, setDetailLicense] = useState<License | null>(null);
+  const [deleteTarget, setDeleteTarget] = useState<License | null>(null);
+  const deleteLicense = useDeleteLicense();
+
+  const handleDelete = async () => {
+    if (!deleteTarget) return;
+    await deleteLicense.mutateAsync(deleteTarget.id);
+    setDeleteTarget(null);
+  };
+
+  return (
+    <div>
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-2xl font-bold text-gray-900">Licenses &amp; Subscriptions</h1>
+          <p className="text-sm text-gray-500 mt-1">
+            Track software seats, costs and renewal dates
+          </p>
+        </div>
+        <Button size="sm" onClick={() => setFormTarget({ mode: "create" })}>
+          <Plus size={15} className="mr-1" />
+          Add License
+        </Button>
+      </div>
+
+      <div className="bg-white rounded-xl border border-gray-200 overflow-hidden">
+        <div className="overflow-x-auto">
+          <table className="w-full text-sm">
+            <thead>
+              <tr className="border-b border-gray-200 bg-gray-50">
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Name</th>
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Vendor</th>
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Seats</th>
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Cost</th>
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Renewal</th>
+                <th className="text-left px-4 py-3 font-medium text-gray-500">Status</th>
+              </tr>
+            </thead>
+            <tbody>
+              {isLoading ? (
+                <tr>
+                  <td colSpan={6} className="text-center py-12 text-gray-400">
+                    Loading licenses...
+                  </td>
+                </tr>
+              ) : licenses.length === 0 ? (
+                <tr>
+                  <td colSpan={6} className="text-center py-12 text-gray-400">
+                    No licenses yet. Click &quot;Add License&quot; to get started.
+                  </td>
+                </tr>
+              ) : (
+                licenses.map((lic) => {
+                  const pct = lic.seatsTotal > 0 ? Math.round((lic.seatsUsed / lic.seatsTotal) * 100) : 0;
+                  return (
+                    <tr
+                      key={lic.id}
+                      onClick={() => setDetailLicense(lic)}
+                      className="border-b border-gray-100 hover:bg-gray-50 cursor-pointer transition-colors"
+                    >
+                      <td className="px-4 py-3 font-medium text-gray-900">{lic.name}</td>
+                      <td className="px-4 py-3 text-gray-600">{lic.vendorId || "—"}</td>
+                      <td className="px-4 py-3">
+                        <div className="flex items-center gap-2 w-32">
+                          <div className="flex-1 h-1.5 bg-gray-100 rounded-full overflow-hidden">
+                            <div
+                              className={`h-full rounded-full ${pct >= 100 ? "bg-red-500" : "bg-gray-900"}`}
+                              style={{ width: `${Math.min(pct, 100)}%` }}
+                            />
+                          </div>
+                          <span className="text-xs text-gray-500 flex-shrink-0">
+                            {lic.seatsUsed}/{lic.seatsTotal}
+                          </span>
+                        </div>
+                      </td>
+                      <td className="px-4 py-3 text-gray-600">
+                        {lic.currency} {lic.cost.toLocaleString()} / {lic.billingPeriod.toLowerCase()}
+                      </td>
+                      <td className="px-4 py-3">
+                        <span
+                          className={`inline-flex items-center gap-1 text-xs ${
+                            lic.renewsSoon ? "text-amber-600 font-medium" : "text-gray-500"
+                          }`}
+                        >
+                          {lic.renewsSoon && <AlertTriangle size={12} />}
+                          {formatDate(lic.expiryDate)}
+                        </span>
+                      </td>
+                      <td className="px-4 py-3">
+                        <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-gray-100 text-gray-700">
+                          {lic.type}
+                        </span>
+                      </td>
+                    </tr>
+                  );
+                })
+              )}
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      {formTarget && (
+        <LicenseFormModal
+          mode={formTarget.mode}
+          license={formTarget.license}
+          onClose={() => setFormTarget(null)}
+        />
+      )}
+
+      {detailLicense && (
+        <LicenseDetailDrawer
+          license={licenses.find((l) => l.id === detailLicense.id) || detailLicense}
+          onClose={() => setDetailLicense(null)}
+          onEdit={() => {
+            setFormTarget({ mode: "edit", license: detailLicense });
+            setDetailLicense(null);
+          }}
+          onDelete={() => {
+            setDeleteTarget(detailLicense);
+            setDetailLicense(null);
+          }}
+        />
+      )}
+
+      {deleteTarget && (
+        <ConfirmDialog
+          title="Delete license?"
+          message={`"${deleteTarget.name}" will be permanently deleted, including its seat assignment history.`}
+          onConfirm={handleDelete}
+          onCancel={() => setDeleteTarget(null)}
+          loading={deleteLicense.isPending}
+        />
+      )}
+    </div>
+  );
+}
+
+function LicenseFormModal({
+  mode,
+  license,
+  onClose,
+}: {
+  mode: "create" | "edit";
+  license?: License;
+  onClose: () => void;
+}) {
+  const [name, setName] = useState(license?.name || "");
+  const [vendorId, setVendorId] = useState(license?.vendorId || "");
+  const [licenseKey, setLicenseKey] = useState("");
+  const [type, setType] = useState<LicenseType>(license?.type || LicenseType.SUBSCRIPTION);
+  const [billingPeriod, setBillingPeriod] = useState<BillingPeriod>(
+    license?.billingPeriod || BillingPeriod.YEARLY,
+  );
+  const [seatsTotal, setSeatsTotal] = useState(String(license?.seatsTotal ?? 1));
+  const [cost, setCost] = useState(String(license?.cost ?? 0));
+  const [currency, setCurrency] = useState(license?.currency || "USD");
+  const [startDate, setStartDate] = useState(license?.startDate?.slice(0, 10) || "");
+  const [expiryDate, setExpiryDate] = useState(license?.expiryDate?.slice(0, 10) || "");
+  const [notes, setNotes] = useState(license?.notes || "");
+  const [error, setError] = useState("");
+
+  const createLicense = useCreateLicense();
+  const updateLicense = useUpdateLicense();
+  const isPending = createLicense.isPending || updateLicense.isPending;
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!name.trim() || (mode === "create" && !licenseKey.trim())) {
+      setError("Name and license key are required");
+      return;
+    }
+    setError("");
+    const payload = {
+      name: name.trim(),
+      vendorId: vendorId.trim() || undefined,
+      type,
+      billingPeriod,
+      seatsTotal: Number(seatsTotal) || 1,
+      cost: Number(cost) || 0,
+      currency,
+      startDate: startDate || undefined,
+      expiryDate: expiryDate || undefined,
+      notes: notes.trim() || undefined,
+    };
+    try {
+      if (mode === "create") {
+        await createLicense.mutateAsync({ ...payload, licenseKey: licenseKey.trim() });
+      } else if (license) {
+        await updateLicense.mutateAsync({ id: license.id, data: payload });
+      }
+      onClose();
+    } catch (err) {
+      setError(errorMessage(err, "Failed to save license."));
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4">
+      <div className="absolute inset-0 bg-black/40" onClick={onClose} />
+      <div className="relative bg-white rounded-2xl shadow-xl w-full max-w-xl max-h-[90vh] overflow-y-auto">
+        <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200 sticky top-0 bg-white">
+          <h2 className="text-base font-semibold text-gray-900">
+            {mode === "create" ? "Add License" : "Edit License"}
+          </h2>
+          <button onClick={onClose} aria-label="Close" className="text-gray-400 hover:text-gray-600">
+            <X size={20} />
+          </button>
+        </div>
+
+        <form onSubmit={handleSubmit} className="px-6 py-5 space-y-4">
+          <div className="grid grid-cols-2 gap-3">
+            <Input id="lic-name" label="Name *" placeholder="e.g. Adobe Creative Cloud" value={name} onChange={(e) => setName(e.target.value)} />
+            <Input id="lic-vendor" label="Vendor" placeholder="e.g. Adobe" value={vendorId} onChange={(e) => setVendorId(e.target.value)} />
+          </div>
+
+          {mode === "create" && (
+            <Input
+              id="lic-key"
+              label="License Key *"
+              placeholder="XXXX-XXXX-XXXX-XXXX"
+              value={licenseKey}
+              onChange={(e) => setLicenseKey(e.target.value)}
+            />
+          )}
+
+          <div className="grid grid-cols-3 gap-3">
+            <div className="flex flex-col gap-1">
+              <label className="text-sm font-medium text-gray-700">Type</label>
+              <select value={type} onChange={(e) => setType(e.target.value as LicenseType)} className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900">
+                {Object.values(LicenseType).map((t) => (
+                  <option key={t} value={t}>{t.charAt(0) + t.slice(1).toLowerCase()}</option>
+                ))}
+              </select>
+            </div>
+            <div className="flex flex-col gap-1">
+              <label className="text-sm font-medium text-gray-700">Billing Period</label>
+              <select value={billingPeriod} onChange={(e) => setBillingPeriod(e.target.value as BillingPeriod)} className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900">
+                {Object.values(BillingPeriod).map((p) => (
+                  <option key={p} value={p}>{p.charAt(0) + p.slice(1).toLowerCase()}</option>
+                ))}
+              </select>
+            </div>
+            <Input id="lic-seats" label="Total Seats" type="number" min={1} value={seatsTotal} onChange={(e) => setSeatsTotal(e.target.value)} />
+          </div>
+
+          <div className="grid grid-cols-2 gap-3">
+            <Input id="lic-cost" label="Cost" type="number" value={cost} onChange={(e) => setCost(e.target.value)} />
+            <Input id="lic-currency" label="Currency" value={currency} onChange={(e) => setCurrency(e.target.value)} />
+          </div>
+
+          <div className="grid grid-cols-2 gap-3">
+            <Input id="lic-start" label="Purchase Date" type="date" value={startDate} onChange={(e) => setStartDate(e.target.value)} />
+            <Input id="lic-expiry" label="Renewal Date" type="date" value={expiryDate} onChange={(e) => setExpiryDate(e.target.value)} />
+          </div>
+
+          <div className="flex flex-col gap-1">
+            <label htmlFor="lic-notes" className="text-sm font-medium text-gray-700">Notes</label>
+            <textarea
+              id="lic-notes"
+              rows={3}
+              value={notes}
+              onChange={(e) => setNotes(e.target.value)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 placeholder:text-gray-400 focus:outline-none focus:ring-2 focus:ring-gray-900 resize-none"
+            />
+          </div>
+
+          {error && (
+            <p className="text-sm text-red-500 bg-red-50 border border-red-200 rounded-lg px-3 py-2">{error}</p>
+          )}
+
+          <div className="flex gap-3 pt-2">
+            <Button type="button" variant="outline" className="flex-1" onClick={onClose}>Cancel</Button>
+            <Button type="submit" className="flex-1" loading={isPending}>
+              {mode === "create" ? "Add License" : "Save Changes"}
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
+
+function LicenseDetailDrawer({
+  license,
+  onClose,
+  onEdit,
+  onDelete,
+}: {
+  license: License;
+  onClose: () => void;
+  onEdit: () => void;
+  onDelete: () => void;
+}) {
+  const { data: assignments = [] } = useLicenseAssignments(license.id);
+  const { data: users = [] } = useUsers();
+  const revealKey = useRevealLicenseKey();
+  const assignSeat = useAssignSeat(license.id);
+  const unassignSeat = useUnassignSeat(license.id);
+
+  const [revealedKey, setRevealedKey] = useState<string | null>(null);
+  const [selectedUserId, setSelectedUserId] = useState("");
+  const [error, setError] = useState("");
+
+  const assignedUserIds = new Set(assignments.map((a) => a.userId));
+  const availableUsers = users.filter((u) => !assignedUserIds.has(u.id));
+  const seatsFull = license.seatsUsed >= license.seatsTotal;
+
+  const handleReveal = async () => {
+    if (revealedKey) {
+      setRevealedKey(null);
+      return;
+    }
+    const { licenseKey } = await revealKey.mutateAsync(license.id);
+    setRevealedKey(licenseKey);
+  };
+
+  const handleAssign = async () => {
+    if (!selectedUserId) return;
+    setError("");
+    try {
+      await assignSeat.mutateAsync(selectedUserId);
+      setSelectedUserId("");
+    } catch (err) {
+      setError(errorMessage(err, "Failed to assign seat."));
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex justify-end">
+      <div className="absolute inset-0 bg-black/40" onClick={onClose} />
+      <div className="relative bg-white w-full max-w-md h-full overflow-y-auto shadow-xl">
+        <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200 sticky top-0 bg-white z-10">
+          <h2 className="text-base font-semibold text-gray-900">{license.name}</h2>
+          <button onClick={onClose} aria-label="Close" className="text-gray-400 hover:text-gray-600">
+            <X size={20} />
+          </button>
+        </div>
+
+        <div className="px-6 py-5 space-y-6">
+          <div className="grid grid-cols-2 gap-4 text-sm">
+            <div>
+              <p className="text-xs text-gray-400">Vendor</p>
+              <p className="text-gray-900">{license.vendorId || "—"}</p>
+            </div>
+            <div>
+              <p className="text-xs text-gray-400">Seats</p>
+              <p className="text-gray-900">{license.seatsUsed} / {license.seatsTotal}</p>
+            </div>
+            <div>
+              <p className="text-xs text-gray-400">Cost</p>
+              <p className="text-gray-900">{license.currency} {license.cost.toLocaleString()} / {license.billingPeriod.toLowerCase()}</p>
+            </div>
+            <div>
+              <p className="text-xs text-gray-400">Renewal</p>
+              <p className={license.renewsSoon ? "text-amber-600 font-medium" : "text-gray-900"}>
+                {formatDate(license.expiryDate)}
+              </p>
+            </div>
+          </div>
+
+          <div>
+            <p className="text-xs text-gray-400 mb-1.5 flex items-center gap-1">
+              <KeyRound size={12} /> License Key
+            </p>
+            <div className="flex items-center gap-2">
+              <code className="flex-1 bg-gray-50 border border-gray-200 rounded-lg px-3 py-2 text-sm text-gray-700 font-mono truncate">
+                {revealedKey ?? "••••••••••••••••"}
+              </code>
+              <Button type="button" variant="outline" size="sm" onClick={handleReveal} loading={revealKey.isPending}>
+                {revealedKey ? <EyeOff size={14} /> : <Eye size={14} />}
+              </Button>
+            </div>
+          </div>
+
+          {license.notes && (
+            <div>
+              <p className="text-xs text-gray-400 mb-1">Notes</p>
+              <p className="text-sm text-gray-700 whitespace-pre-wrap">{license.notes}</p>
+            </div>
+          )}
+
+          <div>
+            <p className="text-sm font-semibold text-gray-900 mb-2">Seat Assignments</p>
+
+            {assignments.length === 0 ? (
+              <p className="text-xs text-gray-400 mb-3">No seats assigned yet.</p>
+            ) : (
+              <ul className="space-y-1.5 mb-3">
+                {assignments.map((a) => {
+                  const user = users.find((u) => u.id === a.userId);
+                  return (
+                    <li
+                      key={a.id}
+                      className="flex items-center justify-between bg-gray-50 border border-gray-200 rounded-lg px-3 py-2"
+                    >
+                      <span className="text-sm text-gray-700">{user?.name || a.userId}</span>
+                      <button
+                        onClick={() => unassignSeat.mutate(a.id)}
+                        disabled={unassignSeat.isPending}
+                        className="text-gray-400 hover:text-red-500 p-1"
+                        title="Unassign seat"
+                      >
+                        <UserMinus size={14} />
+                      </button>
+                    </li>
+                  );
+                })}
+              </ul>
+            )}
+
+            <div className="flex gap-2">
+              <select
+                value={selectedUserId}
+                onChange={(e) => setSelectedUserId(e.target.value)}
+                disabled={seatsFull}
+                className="flex-1 rounded-lg border border-gray-300 px-3 py-2 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900 disabled:bg-gray-50 disabled:text-gray-400"
+              >
+                <option value="">{seatsFull ? "No seats available" : "Select a user..."}</option>
+                {availableUsers.map((u) => (
+                  <option key={u.id} value={u.id}>{u.name}</option>
+                ))}
+              </select>
+              <Button
+                type="button"
+                size="sm"
+                onClick={handleAssign}
+                disabled={seatsFull || !selectedUserId}
+                loading={assignSeat.isPending}
+              >
+                Assign
+              </Button>
+            </div>
+            {error && <p className="text-xs text-red-500 mt-2">{error}</p>}
+          </div>
+
+          <div className="flex gap-3 pt-4 border-t border-gray-100">
+            <Button variant="outline" className="flex-1" onClick={onEdit}>Edit</Button>
+            <Button variant="destructive" className="flex-1" onClick={onDelete}>Delete</Button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/app/(dashboard)/locations/page.tsx b/frontend/app/(dashboard)/locations/page.tsx
new file mode 100644
index 000000000..a5e1d4e56
--- /dev/null
+++ b/frontend/app/(dashboard)/locations/page.tsx
@@ -0,0 +1,432 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { useRouter } from "next/navigation";
+import {
+  ChevronRight,
+  ChevronDown,
+  MapPin,
+  Plus,
+  Pencil,
+  Trash2,
+  Package,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { ConfirmDialog } from "@/components/ui/confirm-dialog";
+import {
+  useLocations,
+  useCreateLocation,
+  useUpdateLocation,
+  useDeleteLocation,
+} from "@/lib/query/hooks/useLocations";
+import { Location, LocationType } from "@/lib/api/locations";
+
+interface TreeNode extends Location {
+  children: TreeNode[];
+}
+
+function buildTree(locations: Location[]): TreeNode[] {
+  const nodes = new Map<string, TreeNode>();
+  locations.forEach((loc) => nodes.set(loc.id, { ...loc, children: [] }));
+  const roots: TreeNode[] = [];
+  nodes.forEach((node) => {
+    if (node.parentLocationId && nodes.has(node.parentLocationId)) {
+      nodes.get(node.parentLocationId)!.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  });
+  const sortRec = (list: TreeNode[]) => {
+    list.sort((a, b) => a.name.localeCompare(b.name));
+    list.forEach((n) => sortRec(n.children));
+  };
+  sortRec(roots);
+  return roots;
+}
+
+function errorMessage(err: unknown, fallback: string): string {
+  return (
+    (err as { response?: { data?: { message?: string } } })?.response?.data?.message || fallback
+  );
+}
+
+export default function LocationsPage() {
+  const router = useRouter();
+  const { data: locations = [], isLoading } = useLocations();
+  const tree = useMemo(() => buildTree(locations), [locations]);
+
+  const [expanded, setExpanded] = useState<Set<string>>(new Set());
+  const [formTarget, setFormTarget] = useState<{
+    mode: "create" | "edit";
+    parentLocationId?: string;
+    location?: Location;
+  } | null>(null);
+  const [deleteTarget, setDeleteTarget] = useState<Location | null>(null);
+  const [deleteError, setDeleteError] = useState("");
+
+  const deleteLocation = useDeleteLocation();
+
+  const toggle = (id: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+
+  const handleDelete = async () => {
+    if (!deleteTarget) return;
+    setDeleteError("");
+    try {
+      await deleteLocation.mutateAsync(deleteTarget.id);
+      setDeleteTarget(null);
+    } catch (err) {
+      setDeleteError(errorMessage(err, "Failed to delete location."));
+    }
+  };
+
+  return (
+    <div>
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-2xl font-bold text-gray-900">Locations</h1>
+          <p className="text-sm text-gray-500 mt-1">
+            Manage the hierarchical structure of sites, buildings and rooms
+          </p>
+        </div>
+        <Button size="sm" onClick={() => setFormTarget({ mode: "create" })}>
+          <Plus size={15} className="mr-1" />
+          Add Root Location
+        </Button>
+      </div>
+
+      <div className="bg-white rounded-xl border border-gray-200 p-2">
+        {isLoading ? (
+          <div className="text-sm text-gray-400 text-center py-12">Loading locations...</div>
+        ) : tree.length === 0 ? (
+          <div className="text-center py-16">
+            <div className="flex justify-center mb-3">
+              <MapPin size={32} className="text-gray-300" />
+            </div>
+            <p className="text-sm font-medium text-gray-700">No locations yet</p>
+            <p className="text-xs text-gray-400 mt-1">
+              Click &quot;Add Root Location&quot; to create your first one.
+            </p>
+          </div>
+        ) : (
+          <ul>
+            {tree.map((node) => (
+              <LocationRow
+                key={node.id}
+                node={node}
+                depth={0}
+                expanded={expanded}
+                onToggle={toggle}
+                onAddChild={(parentLocationId) =>
+                  setFormTarget({ mode: "create", parentLocationId })
+                }
+                onEdit={(location) => setFormTarget({ mode: "edit", location })}
+                onDelete={(location) => {
+                  setDeleteError("");
+                  setDeleteTarget(location);
+                }}
+                onFilterAssets={(id) => router.push(`/assets?locationId=${id}`)}
+              />
+            ))}
+          </ul>
+        )}
+      </div>
+
+      {formTarget && (
+        <LocationFormModal
+          mode={formTarget.mode}
+          location={formTarget.location}
+          parentLocationId={formTarget.parentLocationId}
+          allLocations={locations}
+          onClose={() => setFormTarget(null)}
+        />
+      )}
+
+      {deleteTarget && (
+        <ConfirmDialog
+          title="Delete location?"
+          message={
+            deleteError ||
+            `"${deleteTarget.name}" will be permanently deleted. This is blocked if it still has assets or child locations.`
+          }
+          onConfirm={handleDelete}
+          onCancel={() => setDeleteTarget(null)}
+          loading={deleteLocation.isPending}
+        />
+      )}
+    </div>
+  );
+}
+
+function LocationRow({
+  node,
+  depth,
+  expanded,
+  onToggle,
+  onAddChild,
+  onEdit,
+  onDelete,
+  onFilterAssets,
+}: {
+  node: TreeNode;
+  depth: number;
+  expanded: Set<string>;
+  onToggle: (id: string) => void;
+  onAddChild: (parentId: string) => void;
+  onEdit: (location: Location) => void;
+  onDelete: (location: Location) => void;
+  onFilterAssets: (id: string) => void;
+}) {
+  const isExpanded = expanded.has(node.id);
+  const hasChildren = node.children.length > 0;
+
+  return (
+    <li>
+      <div
+        className="group flex items-center gap-1.5 py-2 px-2 rounded-lg hover:bg-gray-50"
+        style={{ paddingLeft: `${depth * 20 + 8}px` }}
+      >
+        <button
+          onClick={() => hasChildren && onToggle(node.id)}
+          className="w-5 h-5 flex items-center justify-center text-gray-400 flex-shrink-0"
+          aria-label={isExpanded ? "Collapse" : "Expand"}
+          disabled={!hasChildren}
+        >
+          {hasChildren ? (
+            isExpanded ? (
+              <ChevronDown size={15} />
+            ) : (
+              <ChevronRight size={15} />
+            )
+          ) : null}
+        </button>
+
+        <button
+          onClick={() => onFilterAssets(node.id)}
+          className="flex items-center gap-2 min-w-0 text-left flex-1"
+          title="View assets at this location"
+        >
+          <span className="font-medium text-gray-900 truncate">{node.name}</span>
+          <span className="text-xs text-gray-400 font-mono flex-shrink-0">{node.code}</span>
+          <span className="text-xs text-gray-400 flex-shrink-0">{node.type}</span>
+        </button>
+
+        <span className="flex items-center gap-1 text-xs text-gray-400 flex-shrink-0 mr-2">
+          <Package size={12} />
+          {node.totalAssetCount}
+        </span>
+
+        <div className="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity flex-shrink-0">
+          <button
+            onClick={() => onAddChild(node.id)}
+            className="p-1.5 text-gray-400 hover:text-gray-700 hover:bg-gray-100 rounded-lg"
+            title="Add child location"
+          >
+            <Plus size={14} />
+          </button>
+          <button
+            onClick={() => onEdit(node)}
+            className="p-1.5 text-gray-400 hover:text-gray-700 hover:bg-gray-100 rounded-lg"
+            title="Edit location"
+          >
+            <Pencil size={14} />
+          </button>
+          <button
+            onClick={() => onDelete(node)}
+            className="p-1.5 text-gray-400 hover:text-red-500 hover:bg-red-50 rounded-lg"
+            title="Delete location"
+          >
+            <Trash2 size={14} />
+          </button>
+        </div>
+      </div>
+
+      {hasChildren && isExpanded && (
+        <ul>
+          {node.children.map((child) => (
+            <LocationRow
+              key={child.id}
+              node={child}
+              depth={depth + 1}
+              expanded={expanded}
+              onToggle={onToggle}
+              onAddChild={onAddChild}
+              onEdit={onEdit}
+              onDelete={onDelete}
+              onFilterAssets={onFilterAssets}
+            />
+          ))}
+        </ul>
+      )}
+    </li>
+  );
+}
+
+function LocationFormModal({
+  mode,
+  location,
+  parentLocationId,
+  allLocations,
+  onClose,
+}: {
+  mode: "create" | "edit";
+  location?: Location;
+  parentLocationId?: string;
+  allLocations: Location[];
+  onClose: () => void;
+}) {
+  const [name, setName] = useState(location?.name || "");
+  const [code, setCode] = useState(location?.code || "");
+  const [type, setType] = useState<LocationType>(location?.type || LocationType.BUILDING);
+  const [address, setAddress] = useState(location?.address || "");
+  const [parentId, setParentId] = useState(
+    location?.parentLocationId || parentLocationId || "",
+  );
+  const [error, setError] = useState("");
+
+  const createLocation = useCreateLocation();
+  const updateLocation = useUpdateLocation();
+  const isPending = createLocation.isPending || updateLocation.isPending;
+
+  // Prevent moving a location under itself or one of its own descendants
+  const invalidParentIds = useMemo(() => {
+    if (!location) return new Set<string>();
+    const invalid = new Set<string>([location.id]);
+    let added = true;
+    while (added) {
+      added = false;
+      for (const loc of allLocations) {
+        if (loc.parentLocationId && invalid.has(loc.parentLocationId) && !invalid.has(loc.id)) {
+          invalid.add(loc.id);
+          added = true;
+        }
+      }
+    }
+    return invalid;
+  }, [location, allLocations]);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!name.trim() || !code.trim()) {
+      setError("Name and code are required");
+      return;
+    }
+    setError("");
+    try {
+      if (mode === "create") {
+        await createLocation.mutateAsync({
+          name: name.trim(),
+          code: code.trim(),
+          type,
+          address: address.trim() || undefined,
+          parentLocationId: parentId || undefined,
+        });
+      } else if (location) {
+        await updateLocation.mutateAsync({
+          id: location.id,
+          data: {
+            name: name.trim(),
+            code: code.trim(),
+            type,
+            address: address.trim() || undefined,
+            parentLocationId: parentId || undefined,
+          },
+        });
+      }
+      onClose();
+    } catch (err) {
+      setError(errorMessage(err, "Failed to save location."));
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4">
+      <div className="absolute inset-0 bg-black/40" onClick={onClose} />
+      <div className="relative bg-white rounded-2xl shadow-xl w-full max-w-md max-h-[90vh] overflow-y-auto">
+        <form onSubmit={handleSubmit} className="px-6 py-5 space-y-4">
+          <h2 className="text-base font-semibold text-gray-900">
+            {mode === "create" ? "New Location" : "Edit Location"}
+          </h2>
+
+          <Input
+            id="loc-name"
+            label="Name *"
+            placeholder="e.g. Lagos HQ, Floor 3, Room 204"
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+          />
+          <Input
+            id="loc-code"
+            label="Code *"
+            placeholder="e.g. LOS-HQ-F3-204"
+            value={code}
+            onChange={(e) => setCode(e.target.value)}
+          />
+
+          <div className="flex flex-col gap-1">
+            <label className="text-sm font-medium text-gray-700">Type</label>
+            <select
+              value={type}
+              onChange={(e) => setType(e.target.value as LocationType)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+            >
+              {Object.values(LocationType).map((t) => (
+                <option key={t} value={t}>
+                  {t.charAt(0) + t.slice(1).toLowerCase()}
+                </option>
+              ))}
+            </select>
+          </div>
+
+          <div className="flex flex-col gap-1">
+            <label className="text-sm font-medium text-gray-700">Parent location</label>
+            <select
+              value={parentId}
+              onChange={(e) => setParentId(e.target.value)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+            >
+              <option value="">No parent (root level)</option>
+              {allLocations
+                .filter((l) => !invalidParentIds.has(l.id))
+                .map((l) => (
+                  <option key={l.id} value={l.id}>
+                    {l.name} ({l.code})
+                  </option>
+                ))}
+            </select>
+          </div>
+
+          <Input
+            id="loc-address"
+            label="Address"
+            placeholder="Optional address or notes"
+            value={address}
+            onChange={(e) => setAddress(e.target.value)}
+          />
+
+          {error && (
+            <p className="text-sm text-red-500 bg-red-50 border border-red-200 rounded-lg px-3 py-2">
+              {error}
+            </p>
+          )}
+
+          <div className="flex gap-3 pt-2">
+            <Button type="button" variant="outline" className="flex-1" onClick={onClose}>
+              Cancel
+            </Button>
+            <Button type="submit" className="flex-1" loading={isPending}>
+              {mode === "create" ? "Create Location" : "Save Changes"}
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/app/(dashboard)/maintenance/page.tsx b/frontend/app/(dashboard)/maintenance/page.tsx
new file mode 100644
index 000000000..5145df623
--- /dev/null
+++ b/frontend/app/(dashboard)/maintenance/page.tsx
@@ -0,0 +1,507 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import Link from "next/link";
+import {
+  DndContext,
+  DragEndEvent,
+  DragOverlay,
+  DragStartEvent,
+  PointerSensor,
+  useDroppable,
+  useDraggable,
+  useSensor,
+  useSensors,
+} from "@dnd-kit/core";
+import {
+  addMonths,
+  eachDayOfInterval,
+  endOfMonth,
+  endOfWeek,
+  format,
+  isSameDay,
+  isSameMonth,
+  isToday,
+  startOfMonth,
+  startOfWeek,
+  subMonths,
+} from "date-fns";
+import {
+  Calendar as CalendarIcon,
+  Columns3,
+  Plus,
+  ChevronLeft,
+  ChevronRight,
+  AlertCircle,
+  X,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useMaintenanceRecords, useCreateMaintenanceRecord, useUpdateMaintenanceStatus } from "@/lib/query/hooks/useMaintenance";
+import { useAssets, useDepartmentsList } from "@/lib/query/hooks/useAssets";
+import {
+  MaintenanceRecord,
+  MaintenanceStatus,
+  MaintenanceType,
+} from "@/lib/api/maintenance";
+
+const COLUMNS: { status: MaintenanceStatus; label: string }[] = [
+  { status: "SCHEDULED", label: "Scheduled" },
+  { status: "IN_PROGRESS", label: "In Progress" },
+  { status: "COMPLETED", label: "Completed" },
+  { status: "CANCELLED", label: "Cancelled" },
+];
+
+const TYPES: MaintenanceType[] = ["PREVENTIVE", "CORRECTIVE", "SCHEDULED"];
+
+function isOverdue(record: MaintenanceRecord): boolean {
+  if (record.status !== "SCHEDULED" || !record.scheduledDate) return false;
+  return new Date(record.scheduledDate) < new Date(new Date().toDateString());
+}
+
+export default function MaintenancePage() {
+  const [view, setView] = useState<"board" | "calendar">("board");
+  const [typeFilter, setTypeFilter] = useState("");
+  const [departmentFilter, setDepartmentFilter] = useState("");
+  const [from, setFrom] = useState("");
+  const [to, setTo] = useState("");
+  const [showModal, setShowModal] = useState(false);
+
+  const { data: records = [], isLoading } = useMaintenanceRecords({
+    type: (typeFilter as MaintenanceType) || undefined,
+    departmentId: departmentFilter || undefined,
+    from: from || undefined,
+    to: to || undefined,
+  });
+  const { data: assetsPage } = useAssets({ limit: 500 });
+  const { data: departments = [] } = useDepartmentsList();
+  const assetMap = useMemo(() => {
+    const map = new Map<string, string>();
+    (assetsPage?.data ?? []).forEach((a) => map.set(a.id, a.name));
+    return map;
+  }, [assetsPage]);
+
+  return (
+    <div>
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-2xl font-bold text-gray-900">Maintenance</h1>
+          <p className="text-sm text-gray-500 mt-1">
+            All scheduled, in-progress and completed work orders across assets
+          </p>
+        </div>
+        <Button size="sm" onClick={() => setShowModal(true)}>
+          <Plus size={15} className="mr-1" />
+          New Maintenance
+        </Button>
+      </div>
+
+      <div className="flex flex-wrap items-center gap-3 mb-4">
+        <div className="flex gap-1 bg-gray-100 rounded-lg p-1">
+          <button
+            onClick={() => setView("board")}
+            className={`flex items-center gap-1.5 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${
+              view === "board" ? "bg-white text-gray-900 shadow-sm" : "text-gray-500"
+            }`}
+          >
+            <Columns3 size={14} />
+            Board
+          </button>
+          <button
+            onClick={() => setView("calendar")}
+            className={`flex items-center gap-1.5 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${
+              view === "calendar" ? "bg-white text-gray-900 shadow-sm" : "text-gray-500"
+            }`}
+          >
+            <CalendarIcon size={14} />
+            Calendar
+          </button>
+        </div>
+
+        <select
+          value={typeFilter}
+          onChange={(e) => setTypeFilter(e.target.value)}
+          className="text-sm border border-gray-300 rounded-lg px-3 py-2 focus:outline-none focus:ring-2 focus:ring-gray-900 text-gray-700"
+        >
+          <option value="">All Types</option>
+          {TYPES.map((t) => (
+            <option key={t} value={t}>{t.charAt(0) + t.slice(1).toLowerCase()}</option>
+          ))}
+        </select>
+
+        <select
+          value={departmentFilter}
+          onChange={(e) => setDepartmentFilter(e.target.value)}
+          className="text-sm border border-gray-300 rounded-lg px-3 py-2 focus:outline-none focus:ring-2 focus:ring-gray-900 text-gray-700"
+        >
+          <option value="">All Departments</option>
+          {departments.map((d) => (
+            <option key={d.id} value={d.id}>{d.name}</option>
+          ))}
+        </select>
+
+        <div className="flex items-center gap-1.5">
+          <Input id="mnt-from" type="date" value={from} onChange={(e) => setFrom(e.target.value)} className="!py-2" />
+          <span className="text-gray-400 text-sm">to</span>
+          <Input id="mnt-to" type="date" value={to} onChange={(e) => setTo(e.target.value)} className="!py-2" />
+        </div>
+      </div>
+
+      {isLoading ? (
+        <div className="text-sm text-gray-400 text-center py-16">Loading maintenance records...</div>
+      ) : view === "board" ? (
+        <BoardView records={records} assetMap={assetMap} />
+      ) : (
+        <CalendarView records={records} assetMap={assetMap} />
+      )}
+
+      {showModal && (
+        <NewMaintenanceModal onClose={() => setShowModal(false)} />
+      )}
+    </div>
+  );
+}
+
+function BoardView({
+  records,
+  assetMap,
+}: {
+  records: MaintenanceRecord[];
+  assetMap: Map<string, string>;
+}) {
+  const updateStatus = useUpdateMaintenanceStatus();
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }));
+
+  const byStatus = useMemo(() => {
+    const grouped: Record<MaintenanceStatus, MaintenanceRecord[]> = {
+      SCHEDULED: [],
+      IN_PROGRESS: [],
+      COMPLETED: [],
+      CANCELLED: [],
+    };
+    records.forEach((r) => grouped[r.status]?.push(r));
+    return grouped;
+  }, [records]);
+
+  const activeRecord = records.find((r) => r.id === activeId);
+
+  const handleDragStart = (event: DragStartEvent) => {
+    setActiveId(String(event.active.id));
+  };
+
+  const handleDragEnd = (event: DragEndEvent) => {
+    setActiveId(null);
+    const { active, over } = event;
+    if (!over) return;
+    const record = records.find((r) => r.id === active.id);
+    const newStatus = over.id as MaintenanceStatus;
+    if (!record || record.status === newStatus) return;
+    updateStatus.mutate({ id: record.id, status: newStatus });
+  };
+
+  return (
+    <DndContext sensors={sensors} onDragStart={handleDragStart} onDragEnd={handleDragEnd}>
+      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
+        {COLUMNS.map((col) => (
+          <BoardColumn
+            key={col.status}
+            status={col.status}
+            label={col.label}
+            records={byStatus[col.status]}
+            assetMap={assetMap}
+          />
+        ))}
+      </div>
+      <DragOverlay>
+        {activeRecord ? (
+          <MaintenanceCard record={activeRecord} assetName={assetMap.get(activeRecord.assetId)} dragging />
+        ) : null}
+      </DragOverlay>
+    </DndContext>
+  );
+}
+
+function BoardColumn({
+  status,
+  label,
+  records,
+  assetMap,
+}: {
+  status: MaintenanceStatus;
+  label: string;
+  records: MaintenanceRecord[];
+  assetMap: Map<string, string>;
+}) {
+  const { setNodeRef, isOver } = useDroppable({ id: status });
+
+  return (
+    <div
+      ref={setNodeRef}
+      className={`rounded-xl border p-3 min-h-[200px] transition-colors ${
+        isOver ? "border-gray-400 bg-gray-50" : "border-gray-200 bg-gray-50/50"
+      }`}
+    >
+      <div className="flex items-center justify-between mb-3 px-1">
+        <h3 className="text-sm font-semibold text-gray-700">{label}</h3>
+        <span className="text-xs text-gray-400">{records.length}</span>
+      </div>
+      <div className="space-y-2">
+        {records.map((record) => (
+          <DraggableCard key={record.id} record={record} assetName={assetMap.get(record.assetId)} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+function DraggableCard({ record, assetName }: { record: MaintenanceRecord; assetName?: string }) {
+  const { attributes, listeners, setNodeRef, transform, isDragging } = useDraggable({ id: record.id });
+  const style = transform
+    ? { transform: `translate3d(${transform.x}px, ${transform.y}px, 0)`, opacity: isDragging ? 0.4 : 1 }
+    : undefined;
+
+  return (
+    <div ref={setNodeRef} style={style} {...attributes} {...listeners} className="cursor-grab active:cursor-grabbing">
+      <MaintenanceCard record={record} assetName={assetName} />
+    </div>
+  );
+}
+
+const typeColors: Record<MaintenanceType, string> = {
+  PREVENTIVE: "bg-blue-100 text-blue-700",
+  CORRECTIVE: "bg-orange-100 text-orange-700",
+  SCHEDULED: "bg-gray-100 text-gray-700",
+};
+
+function MaintenanceCard({
+  record,
+  assetName,
+  dragging,
+}: {
+  record: MaintenanceRecord;
+  assetName?: string;
+  dragging?: boolean;
+}) {
+  const overdue = isOverdue(record);
+  return (
+    <div
+      className={`bg-white border rounded-lg p-3 shadow-sm ${
+        overdue ? "border-red-300" : "border-gray-200"
+      } ${dragging ? "shadow-lg" : ""}`}
+    >
+      <div className="flex items-center justify-between mb-1.5">
+        <span className={`inline-flex items-center px-1.5 py-0.5 rounded text-[10px] font-medium ${typeColors[record.type]}`}>
+          {record.type}
+        </span>
+        {overdue && (
+          <span className="inline-flex items-center gap-0.5 text-[10px] font-medium text-red-600">
+            <AlertCircle size={11} />
+            Overdue
+          </span>
+        )}
+      </div>
+      <Link
+        href={`/assets/${record.assetId}`}
+        onClick={(e) => e.stopPropagation()}
+        className="text-sm font-medium text-gray-900 hover:underline block truncate"
+      >
+        {assetName || record.assetId}
+      </Link>
+      <p className="text-xs text-gray-500 truncate mt-0.5">{record.title}</p>
+      <div className="flex items-center justify-between mt-2 text-xs text-gray-400">
+        <span>{record.scheduledDate ? format(new Date(record.scheduledDate), "MMM d, yyyy") : "—"}</span>
+        {record.cost > 0 && <span>{record.currency} {record.cost.toLocaleString()}</span>}
+      </div>
+    </div>
+  );
+}
+
+function CalendarView({
+  records,
+  assetMap,
+}: {
+  records: MaintenanceRecord[];
+  assetMap: Map<string, string>;
+}) {
+  const [month, setMonth] = useState(new Date());
+
+  const days = useMemo(() => {
+    const start = startOfWeek(startOfMonth(month));
+    const end = endOfWeek(endOfMonth(month));
+    return eachDayOfInterval({ start, end });
+  }, [month]);
+
+  const recordsByDay = useMemo(() => {
+    const map = new Map<string, MaintenanceRecord[]>();
+    records.forEach((r) => {
+      if (!r.scheduledDate) return;
+      const key = new Date(r.scheduledDate).toDateString();
+      map.set(key, [...(map.get(key) ?? []), r]);
+    });
+    return map;
+  }, [records]);
+
+  return (
+    <div className="bg-white rounded-xl border border-gray-200 p-4">
+      <div className="flex items-center justify-between mb-4">
+        <button onClick={() => setMonth((m) => subMonths(m, 1))} className="p-1.5 text-gray-400 hover:text-gray-700 hover:bg-gray-100 rounded-lg">
+          <ChevronLeft size={16} />
+        </button>
+        <h3 className="text-sm font-semibold text-gray-900">{format(month, "MMMM yyyy")}</h3>
+        <button onClick={() => setMonth((m) => addMonths(m, 1))} className="p-1.5 text-gray-400 hover:text-gray-700 hover:bg-gray-100 rounded-lg">
+          <ChevronRight size={16} />
+        </button>
+      </div>
+
+      <div className="grid grid-cols-7 gap-px bg-gray-100 rounded-lg overflow-hidden">
+        {["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].map((d) => (
+          <div key={d} className="bg-gray-50 text-center text-xs font-medium text-gray-500 py-2">{d}</div>
+        ))}
+        {days.map((day) => {
+          const dayRecords = recordsByDay.get(day.toDateString()) ?? [];
+          return (
+            <div
+              key={day.toISOString()}
+              className={`bg-white min-h-[90px] p-1.5 ${!isSameMonth(day, month) ? "opacity-40" : ""}`}
+            >
+              <span
+                className={`inline-flex items-center justify-center w-5 h-5 text-xs rounded-full ${
+                  isToday(day) ? "bg-gray-900 text-white font-medium" : "text-gray-500"
+                }`}
+              >
+                {format(day, "d")}
+              </span>
+              <div className="mt-1 space-y-1">
+                {dayRecords.slice(0, 3).map((r) => (
+                  <Link
+                    key={r.id}
+                    href={`/assets/${r.assetId}`}
+                    className={`block truncate text-[10px] px-1.5 py-0.5 rounded ${typeColors[r.type]} ${
+                      isOverdue(r) ? "ring-1 ring-red-400" : ""
+                    }`}
+                    title={assetMap.get(r.assetId) || r.assetId}
+                  >
+                    {assetMap.get(r.assetId) || r.assetId}
+                  </Link>
+                ))}
+                {dayRecords.length > 3 && (
+                  <span className="text-[10px] text-gray-400 px-1.5">+{dayRecords.length - 3} more</span>
+                )}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+function NewMaintenanceModal({ onClose }: { onClose: () => void }) {
+  const { data: assetsPage } = useAssets({ limit: 500 });
+  const assets = assetsPage?.data ?? [];
+  const createRecord = useCreateMaintenanceRecord();
+
+  const [assetId, setAssetId] = useState("");
+  const [type, setType] = useState<MaintenanceType>("SCHEDULED");
+  const [title, setTitle] = useState("");
+  const [scheduledDate, setScheduledDate] = useState("");
+  const [cost, setCost] = useState("0");
+  const [notes, setNotes] = useState("");
+  const [error, setError] = useState("");
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!assetId || !scheduledDate) {
+      setError("Asset and scheduled date are required");
+      return;
+    }
+    setError("");
+    try {
+      await createRecord.mutateAsync({
+        assetId,
+        type,
+        title: title.trim() || undefined,
+        scheduledDate,
+        cost: Number(cost) || 0,
+        notes: notes.trim() || undefined,
+      });
+      onClose();
+    } catch (err) {
+      const message =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ||
+        "Failed to schedule maintenance.";
+      setError(message);
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4">
+      <div className="absolute inset-0 bg-black/40" onClick={onClose} />
+      <div className="relative bg-white rounded-2xl shadow-xl w-full max-w-md max-h-[90vh] overflow-y-auto">
+        <div className="flex items-center justify-between px-6 py-4 border-b border-gray-200 sticky top-0 bg-white">
+          <h2 className="text-base font-semibold text-gray-900">New Maintenance</h2>
+          <button onClick={onClose} aria-label="Close" className="text-gray-400 hover:text-gray-600">
+            <X size={20} />
+          </button>
+        </div>
+
+        <form onSubmit={handleSubmit} className="px-6 py-5 space-y-4">
+          <div className="flex flex-col gap-1">
+            <label className="text-sm font-medium text-gray-700">Asset *</label>
+            <select
+              value={assetId}
+              onChange={(e) => setAssetId(e.target.value)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+            >
+              <option value="">Select asset</option>
+              {assets.map((a) => (
+                <option key={a.id} value={a.id}>{a.name}</option>
+              ))}
+            </select>
+          </div>
+
+          <div className="flex flex-col gap-1">
+            <label className="text-sm font-medium text-gray-700">Type</label>
+            <select
+              value={type}
+              onChange={(e) => setType(e.target.value as MaintenanceType)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+            >
+              {TYPES.map((t) => (
+                <option key={t} value={t}>{t.charAt(0) + t.slice(1).toLowerCase()}</option>
+              ))}
+            </select>
+          </div>
+
+          <Input id="mnt-title" label="Title" placeholder="e.g. Quarterly service" value={title} onChange={(e) => setTitle(e.target.value)} />
+
+          <div className="grid grid-cols-2 gap-3">
+            <Input id="mnt-date" label="Scheduled Date *" type="date" value={scheduledDate} onChange={(e) => setScheduledDate(e.target.value)} />
+            <Input id="mnt-cost" label="Cost" type="number" value={cost} onChange={(e) => setCost(e.target.value)} />
+          </div>
+
+          <div className="flex flex-col gap-1">
+            <label htmlFor="mnt-notes" className="text-sm font-medium text-gray-700">Notes</label>
+            <textarea
+              id="mnt-notes"
+              rows={3}
+              value={notes}
+              onChange={(e) => setNotes(e.target.value)}
+              className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 placeholder:text-gray-400 focus:outline-none focus:ring-2 focus:ring-gray-900 resize-none"
+            />
+          </div>
+
+          {error && (
+            <p className="text-sm text-red-500 bg-red-50 border border-red-200 rounded-lg px-3 py-2">{error}</p>
+          )}
+
+          <div className="flex gap-3 pt-2">
+            <Button type="button" variant="outline" className="flex-1" onClick={onClose}>Cancel</Button>
+            <Button type="submit" className="flex-1" loading={createRecord.isPending}>Schedule</Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/components/assets/create-asset-modal.tsx b/frontend/components/assets/create-asset-modal.tsx
index f60cd9379..d77ca057d 100644
--- a/frontend/components/assets/create-asset-modal.tsx
+++ b/frontend/components/assets/create-asset-modal.tsx
@@ -9,6 +9,8 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { useCreateAsset, useCategories } from "@/lib/query/hooks/useAssets";
 import { useDepartments } from "@/lib/query/hooks/useAsset";
+import { useLocations } from "@/lib/query/hooks/useLocations";
+import { flattenLocationsForSelect } from "@/lib/api/locations";
 import { AssetStatus, AssetCondition } from "@/lib/query/types/asset";
 
 const schema = z.object({
@@ -19,6 +21,7 @@ const schema = z.object({
   manufacturer: z.string().optional(),
   model: z.string().optional(),
   location: z.string().optional(),
+  locationId: z.string().optional(),
   condition: z.nativeEnum(AssetCondition).optional(),
   status: z.nativeEnum(AssetStatus).optional(),
   purchasePrice: z.string().optional(),
@@ -35,6 +38,8 @@ interface Props {
 export function CreateAssetModal({ onClose, onSuccess }: Props) {
   const { data: departments = [] } = useDepartments();
   const { data: categories = [] } = useCategories();
+  const { data: locations = [] } = useLocations();
+  const locationOptions = flattenLocationsForSelect(locations);
   const createAsset = useCreateAsset();
 
   const {
@@ -60,6 +65,7 @@ export function CreateAssetModal({ onClose, onSuccess }: Props) {
         manufacturer: values.manufacturer || undefined,
         model: values.model || undefined,
         location: values.location || undefined,
+        locationId: values.locationId || undefined,
         condition: values.condition,
         status: values.status,
         purchasePrice: values.purchasePrice
@@ -161,14 +167,29 @@ export function CreateAssetModal({ onClose, onSuccess }: Props) {
               placeholder="SN-12345"
               {...register("serialNumber")}
             />
-            <Input
-              id="location"
-              label="Location"
-              placeholder="Floor 2, Room 204"
-              {...register("location")}
-            />
+            <div className="flex flex-col gap-1">
+              <label className="text-sm font-medium text-gray-700">Location</label>
+              <select
+                {...register("locationId")}
+                className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+              >
+                <option value="">Unassigned</option>
+                {locationOptions.map((opt) => (
+                  <option key={opt.id} value={opt.id}>
+                    {opt.label}
+                  </option>
+                ))}
+              </select>
+            </div>
           </div>
 
+          <Input
+            id="location"
+            label="Location notes (optional)"
+            placeholder="e.g. desk 4, near the window"
+            {...register("location")}
+          />
+
           <div className="grid grid-cols-2 gap-3">
             <Input
               id="manufacturer"
diff --git a/frontend/components/assets/edit-asset-modal.tsx b/frontend/components/assets/edit-asset-modal.tsx
index c27b6f79c..c3f6b3d6b 100644
--- a/frontend/components/assets/edit-asset-modal.tsx
+++ b/frontend/components/assets/edit-asset-modal.tsx
@@ -7,6 +7,8 @@ import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { Textarea } from '@/components/ui/textarea';
 import { useUpdateAsset } from '@/lib/query/hooks/useAsset';
+import { useLocations } from '@/lib/query/hooks/useLocations';
+import { flattenLocationsForSelect } from '@/lib/api/locations';
 import type { Asset } from '@/lib/query/types/asset';
 
 interface EditAssetModalProps {
@@ -19,16 +21,20 @@ export function EditAssetModal({ asset, isOpen, onClose }: EditAssetModalProps)
   const [name, setName] = useState(asset.name);
   const [description, setDescription] = useState(asset.description || '');
   const [location, setLocation] = useState(asset.location || '');
+  const [locationId, setLocationId] = useState(asset.locationId || '');
   const [manufacturer, setManufacturer] = useState(asset.manufacturer || '');
   const [model, setModel] = useState(asset.model || '');
   const [serialNumber, setSerialNumber] = useState(asset.serialNumber || '');
   const updateAsset = useUpdateAsset(asset.id, { onSuccess: onClose });
+  const { data: locations = [] } = useLocations();
+  const locationOptions = flattenLocationsForSelect(locations);
 
   useEffect(() => {
     if (isOpen) {
       setName(asset.name);
       setDescription(asset.description || '');
       setLocation(asset.location || '');
+      setLocationId(asset.locationId || '');
       setManufacturer(asset.manufacturer || '');
       setModel(asset.model || '');
       setSerialNumber(asset.serialNumber || '');
@@ -41,6 +47,7 @@ export function EditAssetModal({ asset, isOpen, onClose }: EditAssetModalProps)
       name,
       description: description || undefined,
       location: location || undefined,
+      locationId: locationId || undefined,
       manufacturer: manufacturer || undefined,
       model: model || undefined,
       serialNumber: serialNumber || undefined,
@@ -64,7 +71,23 @@ export function EditAssetModal({ asset, isOpen, onClose }: EditAssetModalProps)
               <Textarea id="edit-description" value={description} onChange={(e) => setDescription(e.target.value)} />
             </div>
             <div>
-              <Label htmlFor="edit-location">Location</Label>
+              <Label htmlFor="edit-locationId">Location</Label>
+              <select
+                id="edit-locationId"
+                value={locationId}
+                onChange={(e) => setLocationId(e.target.value)}
+                className="w-full rounded-lg border border-gray-300 px-3 py-2.5 text-sm text-gray-900 focus:outline-none focus:ring-2 focus:ring-gray-900"
+              >
+                <option value="">Unassigned</option>
+                {locationOptions.map((opt) => (
+                  <option key={opt.id} value={opt.id}>
+                    {opt.label}
+                  </option>
+                ))}
+              </select>
+            </div>
+            <div>
+              <Label htmlFor="edit-location">Location notes (optional)</Label>
               <Input id="edit-location" value={location} onChange={(e) => setLocation(e.target.value)} />
             </div>
             <div>
diff --git a/frontend/components/layout/sidebar.tsx b/frontend/components/layout/sidebar.tsx
index 0d117bec7..ced3ac5db 100644
--- a/frontend/components/layout/sidebar.tsx
+++ b/frontend/components/layout/sidebar.tsx
@@ -13,12 +13,20 @@ import {
   Settings,
   LogOut,
   X,
+  MapPin,
+  KeyRound,
+  Wrench,
+  ClipboardCheck,
 } from "lucide-react";
 import { useAuthStore } from "@/store/auth.store";
 
 const navItems = [
   { href: "/dashboard", label: "Dashboard", icon: LayoutDashboard },
   { href: "/assets", label: "Assets", icon: Package },
+  { href: "/locations", label: "Locations", icon: MapPin },
+  { href: "/maintenance", label: "Maintenance", icon: Wrench },
+  { href: "/audits", label: "Audits", icon: ClipboardCheck },
+  { href: "/licenses", label: "Licenses", icon: KeyRound },
   { href: "/users", label: "Users", icon: Users },
   { href: "/departments", label: "Organisation", icon: Building2 },
   { href: "/reports", label: "Reports", icon: BarChart3 },
diff --git a/frontend/components/layout/topbar.tsx b/frontend/components/layout/topbar.tsx
index 0885c5d5b..c016a2e70 100644
--- a/frontend/components/layout/topbar.tsx
+++ b/frontend/components/layout/topbar.tsx
@@ -8,6 +8,10 @@ import { useAuthStore } from "@/store/auth.store";
 const pageTitles: Record<string, string> = {
   "/dashboard": "Dashboard",
   "/assets": "Assets",
+  "/locations": "Locations",
+  "/maintenance": "Maintenance",
+  "/audits": "Audits / Stocktake",
+  "/licenses": "Licenses & Subscriptions",
   "/users": "Users",
   "/departments": "Organisation",
   "/reports": "Reports",
diff --git a/frontend/components/ui/csv.tsx b/frontend/components/ui/csv.tsx
index 9aca58ee6..4d376ea92 100644
--- a/frontend/components/ui/csv.tsx
+++ b/frontend/components/ui/csv.tsx
@@ -1,115 +1,75 @@
 "use client";
 
-import { useRouter, usePathname } from "next/navigation";
-import { useState, useRef, useEffect } from "react";
-import { Menu, User, ChevronDown } from "lucide-react";
-import { useAuthStore } from "@/store/auth.store";
+import { Download } from "lucide-react";
+import { Button } from "./button";
 
-const pageTitles: Record<string, string> = {
-  "/dashboard": "Dashboard",
-  "/assets": "Assets",
-  "/users": "Users",
-  "/departments": "Organisation",
-  "/reports": "Reports",
-  "/settings": "Settings",
-};
-
-function getPageTitle(pathname: string): string {
-  for (const [prefix, title] of Object.entries(pageTitles)) {
-    if (pathname === prefix || pathname.startsWith(`${prefix}/`)) return title;
+function toCsvValue(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  const str = String(value);
+  if (/[",\n]/.test(str)) {
+    return `"${str.replace(/"/g, '""')}"`;
   }
-  return "Dashboard";
+  return str;
 }
 
-interface TopbarProps {
-  onMenuClick?: () => void;
+/** Converts an array of flat objects into CSV text (header row + one row per record). */
+export function toCsv<T extends Record<string, unknown>>(
+  rows: T[],
+  columns: { key: keyof T; label: string }[],
+): string {
+  const header = columns.map((c) => toCsvValue(c.label)).join(",");
+  const lines = rows.map((row) =>
+    columns.map((c) => toCsvValue(row[c.key])).join(","),
+  );
+  return [header, ...lines].join("\n");
 }
 
-export function Topbar({ onMenuClick }: TopbarProps) {
-  const router = useRouter();
-  const pathname = usePathname();
-  const { user, logout } = useAuthStore();
-  const [dropdownOpen, setDropdownOpen] = useState(false);
-  const dropdownRef = useRef<HTMLDivElement>(null);
-
-  const handleLogout = async () => {
-    setDropdownOpen(false);
-    await logout();
-    router.push("/login");
-  };
+/** Triggers a browser download of the given CSV text. */
+export function downloadCsv(filename: string, csvText: string) {
+  const blob = new Blob([csvText], { type: "text/csv;charset=utf-8;" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename.endsWith(".csv") ? filename : `${filename}.csv`;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
 
-  // Close dropdown on outside click
-  useEffect(() => {
-    function handleClick(e: MouseEvent) {
-      if (dropdownRef.current && !dropdownRef.current.contains(e.target as Node)) {
-        setDropdownOpen(false);
-      }
-    }
-    document.addEventListener("mousedown", handleClick);
-    return () => document.removeEventListener("mousedown", handleClick);
-  }, []);
+export function exportToCsv<T extends Record<string, unknown>>(
+  filename: string,
+  rows: T[],
+  columns: { key: keyof T; label: string }[],
+) {
+  downloadCsv(filename, toCsv(rows, columns));
+}
 
-  const initials = user
-    ? `${user.firstName[0]}${user.lastName[0]}`.toUpperCase()
-    : "?";
+interface CsvExportButtonProps<T extends Record<string, unknown>> {
+  filename: string;
+  rows: T[];
+  columns: { key: keyof T; label: string }[];
+  label?: string;
+  disabled?: boolean;
+}
 
+export function CsvExportButton<T extends Record<string, unknown>>({
+  filename,
+  rows,
+  columns,
+  label = "Export CSV",
+  disabled,
+}: CsvExportButtonProps<T>) {
   return (
-    <header className="fixed top-0 left-0 lg:left-60 right-0 h-14 bg-white border-b border-gray-200 flex items-center justify-between px-4 lg:px-6 z-20">
-      {/* Left: hamburger (mobile) + page title */}
-      <div className="flex items-center gap-3">
-        <button
-          onClick={onMenuClick}
-          className="lg:hidden text-gray-500 hover:text-gray-900"
-          aria-label="Open menu"
-        >
-          <Menu size={20} />
-        </button>
-        <h1 className="text-sm font-semibold text-gray-900">
-          {getPageTitle(pathname)}
-        </h1>
-      </div>
-
-      {/* Right: user dropdown */}
-      <div className="relative" ref={dropdownRef}>
-        <button
-          onClick={() => setDropdownOpen((v) => !v)}
-          className="flex items-center gap-2.5 hover:opacity-80 transition-opacity"
-        >
-          <div className="w-8 h-8 rounded-full bg-gray-200 flex items-center justify-center">
-            {user ? (
-              <span className="text-xs font-semibold text-gray-700">{initials}</span>
-            ) : (
-              <User size={15} className="text-gray-500" />
-            )}
-          </div>
-          {user && (
-            <div className="hidden sm:block text-left">
-              <p className="text-sm font-medium text-gray-900 leading-none">
-                {user.firstName} {user.lastName}
-              </p>
-              <p className="text-xs text-gray-400 mt-0.5 capitalize">{user.role}</p>
-            </div>
-          )}
-          <ChevronDown size={14} className="text-gray-400 hidden sm:block" />
-        </button>
-
-        {dropdownOpen && (
-          <div className="absolute right-0 mt-2 w-44 bg-white border border-gray-200 rounded-lg shadow-md py-1 z-50">
-            <button
-              onClick={() => { setDropdownOpen(false); router.push("/settings"); }}
-              className="w-full text-left px-4 py-2 text-sm text-gray-700 hover:bg-gray-50"
-            >
-              View Profile
-            </button>
-            <button
-              onClick={handleLogout}
-              className="w-full text-left px-4 py-2 text-sm text-red-600 hover:bg-gray-50"
-            >
-              Logout
-            </button>
-          </div>
-        )}
-      </div>
-    </header>
+    <Button
+      type="button"
+      variant="outline"
+      size="sm"
+      disabled={disabled || rows.length === 0}
+      onClick={() => exportToCsv(filename, rows, columns)}
+    >
+      <Download size={15} className="mr-1.5" />
+      {label}
+    </Button>
   );
 }
diff --git a/frontend/lib/api/assets.ts b/frontend/lib/api/assets.ts
index 9a57c51d8..b8c384d6b 100644
--- a/frontend/lib/api/assets.ts
+++ b/frontend/lib/api/assets.ts
@@ -30,6 +30,7 @@ export interface AssetListFilters {
   condition?: string;
   categoryId?: string;
   departmentId?: string;
+  locationId?: string;
   page?: number;
   limit?: number;
 }
@@ -54,6 +55,7 @@ export interface CreateAssetInput {
   status?: string;
   condition?: string;
   location?: string;
+  locationId?: string;
   assignedToId?: string;
   manufacturer?: string;
   model?: string;
diff --git a/frontend/lib/api/audits.ts b/frontend/lib/api/audits.ts
new file mode 100644
index 000000000..2239cc238
--- /dev/null
+++ b/frontend/lib/api/audits.ts
@@ -0,0 +1,69 @@
+import { api } from '../api';
+
+export type AuditSessionStatus = 'DRAFT' | 'IN_PROGRESS' | 'COMPLETED';
+export type AuditItemResult = 'PENDING' | 'FOUND' | 'MISSING' | 'WRONG_LOCATION' | 'DAMAGED';
+
+export interface AuditItem {
+  id: string;
+  auditSessionId: string;
+  assetId: string;
+  expectedLocationId?: string | null;
+  result: AuditItemResult;
+  note?: string | null;
+  checkedAt?: string | null;
+  createdAt: string;
+}
+
+export interface AuditSessionSummary {
+  id: string;
+  name: string;
+  status: AuditSessionStatus;
+  scopeDepartmentId?: string | null;
+  scopeLocationId?: string | null;
+  createdByUserId?: string | null;
+  completedAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  totalItems: number;
+  checkedItems: number;
+  progressPercent: number;
+  discrepancyCount: number;
+}
+
+export interface AuditSessionDetail extends AuditSessionSummary {
+  items: AuditItem[];
+}
+
+export interface CreateAuditSessionInput {
+  name: string;
+  departmentId?: string;
+  locationId?: string;
+}
+
+export interface RecordAuditItemInput {
+  result: AuditItemResult;
+  note?: string;
+}
+
+export const auditApiClient = {
+  getAuditSessions: (): Promise<AuditSessionSummary[]> =>
+    api.get<AuditSessionSummary[]>('/audits').then((r) => r.data),
+
+  getAuditSession: (id: string): Promise<AuditSessionDetail> =>
+    api.get<AuditSessionDetail>(`/audits/${id}`).then((r) => r.data),
+
+  createAuditSession: (data: CreateAuditSessionInput): Promise<AuditSessionDetail> =>
+    api.post<AuditSessionDetail>('/audits', data).then((r) => r.data),
+
+  recordAuditItem: (
+    sessionId: string,
+    itemId: string,
+    data: RecordAuditItemInput,
+  ): Promise<AuditSessionDetail> =>
+    api
+      .patch<AuditSessionDetail>(`/audits/${sessionId}/items/${itemId}`, data)
+      .then((r) => r.data),
+
+  completeAuditSession: (id: string): Promise<AuditSessionDetail> =>
+    api.post<AuditSessionDetail>(`/audits/${id}/complete`).then((r) => r.data),
+};
diff --git a/frontend/lib/api/licenses.ts b/frontend/lib/api/licenses.ts
new file mode 100644
index 000000000..03865ae95
--- /dev/null
+++ b/frontend/lib/api/licenses.ts
@@ -0,0 +1,86 @@
+import { api } from '../api';
+
+export enum LicenseType {
+  PERPETUAL = 'PERPETUAL',
+  SUBSCRIPTION = 'SUBSCRIPTION',
+}
+
+export enum BillingPeriod {
+  MONTHLY = 'MONTHLY',
+  YEARLY = 'YEARLY',
+  ONE_TIME = 'ONE_TIME',
+}
+
+export interface License {
+  id: string;
+  name: string;
+  vendorId?: string | null;
+  type: LicenseType;
+  billingPeriod: BillingPeriod;
+  seatsTotal: number;
+  seatsUsed: number;
+  startDate?: string | null;
+  expiryDate?: string | null;
+  cost: number;
+  currency: string;
+  autoRenew: boolean;
+  notes?: string | null;
+  renewsSoon: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SeatAssignment {
+  id: string;
+  licenseId: string;
+  userId: string;
+  assignedAt: string;
+  unassignedAt?: string | null;
+}
+
+export interface CreateLicenseInput {
+  name: string;
+  vendorId?: string;
+  licenseKey: string;
+  type?: LicenseType;
+  billingPeriod?: BillingPeriod;
+  seatsTotal: number;
+  startDate?: string;
+  expiryDate?: string;
+  cost?: number;
+  currency?: string;
+  autoRenew?: boolean;
+  notes?: string;
+}
+
+export interface UpdateLicenseInput extends Partial<CreateLicenseInput> {}
+
+export const licenseApiClient = {
+  getLicenses: (): Promise<License[]> => api.get<License[]>('/licenses').then((r) => r.data),
+
+  getLicense: (id: string): Promise<License> =>
+    api.get<License>(`/licenses/${id}`).then((r) => r.data),
+
+  createLicense: (data: CreateLicenseInput): Promise<License> =>
+    api.post<License>('/licenses', data).then((r) => r.data),
+
+  updateLicense: (id: string, data: UpdateLicenseInput): Promise<License> =>
+    api.patch<License>(`/licenses/${id}`, data).then((r) => r.data),
+
+  deleteLicense: (id: string): Promise<void> =>
+    api.delete(`/licenses/${id}`).then(() => undefined),
+
+  revealKey: (id: string): Promise<{ licenseKey: string }> =>
+    api.post<{ licenseKey: string }>(`/licenses/${id}/reveal-key`).then((r) => r.data),
+
+  getAssignments: (id: string): Promise<SeatAssignment[]> =>
+    api.get<SeatAssignment[]>(`/licenses/${id}/assignments`).then((r) => r.data),
+
+  assignSeat: (id: string, userId: string): Promise<License> =>
+    api.post<License>(`/licenses/${id}/assign`, { userId }).then((r) => r.data),
+
+  unassignSeat: (id: string, assignmentId: string): Promise<License> =>
+    api
+      .post<License>(`/licenses/${id}/assignments/${assignmentId}/unassign`)
+      .then((r) => r.data),
+};
diff --git a/frontend/lib/api/locations.ts b/frontend/lib/api/locations.ts
new file mode 100644
index 000000000..5485c6b49
--- /dev/null
+++ b/frontend/lib/api/locations.ts
@@ -0,0 +1,77 @@
+import { api } from '../api';
+
+export enum LocationType {
+  BUILDING = 'BUILDING',
+  FLOOR = 'FLOOR',
+  ROOM = 'ROOM',
+  STORAGE = 'STORAGE',
+}
+
+export interface Location {
+  id: string;
+  name: string;
+  code: string;
+  type: LocationType;
+  address?: string | null;
+  parentLocationId?: string | null;
+  branchId?: string | null;
+  assetCount: number;
+  totalAssetCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateLocationInput {
+  name: string;
+  code: string;
+  type?: LocationType;
+  address?: string;
+  parentLocationId?: string;
+  branchId?: string;
+}
+
+export interface UpdateLocationInput extends Partial<CreateLocationInput> {}
+
+export interface LocationOption {
+  id: string;
+  label: string;
+  depth: number;
+}
+
+/** Flattens locations into a depth-first, indentable list suitable for a <select>. */
+export function flattenLocationsForSelect(locations: Location[]): LocationOption[] {
+  const byParent = new Map<string, Location[]>();
+  for (const loc of locations) {
+    const key = loc.parentLocationId ?? '';
+    byParent.set(key, [...(byParent.get(key) ?? []), loc]);
+  }
+
+  const options: LocationOption[] = [];
+  const visit = (parentId: string, depth: number) => {
+    const children = [...(byParent.get(parentId) ?? [])].sort((a, b) =>
+      a.name.localeCompare(b.name),
+    );
+    for (const child of children) {
+      options.push({ id: child.id, label: `${'— '.repeat(depth)}${child.name}`, depth });
+      visit(child.id, depth + 1);
+    }
+  };
+  visit('', 0);
+  return options;
+}
+
+export const locationApiClient = {
+  getLocations: (): Promise<Location[]> => api.get<Location[]>('/locations').then((r) => r.data),
+
+  getLocation: (id: string): Promise<Location> =>
+    api.get<Location>(`/locations/${id}`).then((r) => r.data),
+
+  createLocation: (data: CreateLocationInput): Promise<Location> =>
+    api.post<Location>('/locations', data).then((r) => r.data),
+
+  updateLocation: (id: string, data: UpdateLocationInput): Promise<Location> =>
+    api.patch<Location>(`/locations/${id}`, data).then((r) => r.data),
+
+  deleteLocation: (id: string): Promise<void> =>
+    api.delete(`/locations/${id}`).then(() => undefined),
+};
diff --git a/frontend/lib/api/maintenance.ts b/frontend/lib/api/maintenance.ts
new file mode 100644
index 000000000..143fc3ce1
--- /dev/null
+++ b/frontend/lib/api/maintenance.ts
@@ -0,0 +1,63 @@
+import { api } from '../api';
+
+export type MaintenanceType = 'PREVENTIVE' | 'CORRECTIVE' | 'SCHEDULED';
+export type MaintenanceStatus = 'SCHEDULED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED';
+
+export interface MaintenanceRecord {
+  id: string;
+  assetId: string;
+  title: string;
+  description?: string | null;
+  type: MaintenanceType;
+  status: MaintenanceStatus;
+  vendorId?: string | null;
+  performedByUserId?: string | null;
+  cost: number;
+  currency: string;
+  scheduledDate?: string | null;
+  completedDate?: string | null;
+  notes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface MaintenanceFilters {
+  assetId?: string;
+  status?: MaintenanceStatus;
+  type?: MaintenanceType;
+  departmentId?: string;
+  from?: string;
+  to?: string;
+}
+
+export interface CreateMaintenanceRecordInput {
+  assetId: string;
+  title?: string;
+  description?: string;
+  type?: MaintenanceType;
+  vendorId?: string;
+  cost?: number;
+  currency?: string;
+  scheduledDate: string;
+  notes?: string;
+}
+
+export const maintenanceApiClient = {
+  getMaintenanceRecords: (filters?: MaintenanceFilters): Promise<MaintenanceRecord[]> =>
+    api.get<MaintenanceRecord[]>('/maintenance', { params: filters }).then((r) => r.data),
+
+  getMaintenanceRecord: (id: string): Promise<MaintenanceRecord> =>
+    api.get<MaintenanceRecord>(`/maintenance/${id}`).then((r) => r.data),
+
+  createMaintenanceRecord: (data: CreateMaintenanceRecordInput): Promise<MaintenanceRecord> =>
+    api.post<MaintenanceRecord>('/maintenance', data).then((r) => r.data),
+
+  updateMaintenanceRecord: (
+    id: string,
+    data: Partial<CreateMaintenanceRecordInput> & { status?: MaintenanceStatus; completedDate?: string },
+  ): Promise<MaintenanceRecord> =>
+    api.patch<MaintenanceRecord>(`/maintenance/${id}`, data).then((r) => r.data),
+
+  updateMaintenanceStatus: (id: string, status: MaintenanceStatus): Promise<MaintenanceRecord> =>
+    api.patch<MaintenanceRecord>(`/maintenance/${id}`, { status }).then((r) => r.data),
+};
diff --git a/frontend/lib/query/hooks/useAudits.ts b/frontend/lib/query/hooks/useAudits.ts
new file mode 100644
index 000000000..cdb2568b2
--- /dev/null
+++ b/frontend/lib/query/hooks/useAudits.ts
@@ -0,0 +1,57 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  auditApiClient,
+  AuditSessionDetail,
+  AuditSessionSummary,
+  CreateAuditSessionInput,
+  RecordAuditItemInput,
+} from '@/lib/api/audits';
+import { queryKeys } from '../keys';
+
+export function useAuditSessions() {
+  return useQuery<AuditSessionSummary[]>({
+    queryKey: queryKeys.audits.list(),
+    queryFn: () => auditApiClient.getAuditSessions(),
+  });
+}
+
+export function useAuditSession(id?: string) {
+  return useQuery<AuditSessionDetail>({
+    queryKey: queryKeys.audits.detail(id ?? ''),
+    queryFn: () => auditApiClient.getAuditSession(id as string),
+    enabled: !!id,
+  });
+}
+
+export function useCreateAuditSession() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CreateAuditSessionInput) => auditApiClient.createAuditSession(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.audits.all });
+    },
+  });
+}
+
+export function useRecordAuditItem(sessionId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ itemId, data }: { itemId: string; data: RecordAuditItemInput }) =>
+      auditApiClient.recordAuditItem(sessionId, itemId, data),
+    onSuccess: (updated) => {
+      queryClient.setQueryData(queryKeys.audits.detail(sessionId), updated);
+      queryClient.invalidateQueries({ queryKey: queryKeys.audits.list() });
+    },
+  });
+}
+
+export function useCompleteAuditSession(sessionId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () => auditApiClient.completeAuditSession(sessionId),
+    onSuccess: (updated) => {
+      queryClient.setQueryData(queryKeys.audits.detail(sessionId), updated);
+      queryClient.invalidateQueries({ queryKey: queryKeys.audits.list() });
+    },
+  });
+}
diff --git a/frontend/lib/query/hooks/useLicenses.ts b/frontend/lib/query/hooks/useLicenses.ts
new file mode 100644
index 000000000..c2d71f3a7
--- /dev/null
+++ b/frontend/lib/query/hooks/useLicenses.ts
@@ -0,0 +1,91 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  licenseApiClient,
+  CreateLicenseInput,
+  UpdateLicenseInput,
+  License,
+  SeatAssignment,
+} from '@/lib/api/licenses';
+import { queryKeys } from '../keys';
+
+export function useLicenses() {
+  return useQuery<License[]>({
+    queryKey: queryKeys.licenses.list(),
+    queryFn: () => licenseApiClient.getLicenses(),
+  });
+}
+
+export function useLicense(id?: string) {
+  return useQuery<License>({
+    queryKey: queryKeys.licenses.detail(id ?? ''),
+    queryFn: () => licenseApiClient.getLicense(id as string),
+    enabled: !!id,
+  });
+}
+
+export function useLicenseAssignments(id?: string) {
+  return useQuery<SeatAssignment[]>({
+    queryKey: queryKeys.licenses.assignments(id ?? ''),
+    queryFn: () => licenseApiClient.getAssignments(id as string),
+    enabled: !!id,
+  });
+}
+
+export function useCreateLicense() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CreateLicenseInput) => licenseApiClient.createLicense(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.all });
+    },
+  });
+}
+
+export function useUpdateLicense() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: UpdateLicenseInput }) =>
+      licenseApiClient.updateLicense(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.all });
+    },
+  });
+}
+
+export function useDeleteLicense() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => licenseApiClient.deleteLicense(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.all });
+    },
+  });
+}
+
+export function useRevealLicenseKey() {
+  return useMutation({
+    mutationFn: (id: string) => licenseApiClient.revealKey(id),
+  });
+}
+
+export function useAssignSeat(licenseId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (userId: string) => licenseApiClient.assignSeat(licenseId, userId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.assignments(licenseId) });
+    },
+  });
+}
+
+export function useUnassignSeat(licenseId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (assignmentId: string) => licenseApiClient.unassignSeat(licenseId, assignmentId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.licenses.assignments(licenseId) });
+    },
+  });
+}
diff --git a/frontend/lib/query/hooks/useLocations.ts b/frontend/lib/query/hooks/useLocations.ts
new file mode 100644
index 000000000..1396d399a
--- /dev/null
+++ b/frontend/lib/query/hooks/useLocations.ts
@@ -0,0 +1,46 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  locationApiClient,
+  CreateLocationInput,
+  UpdateLocationInput,
+  Location,
+} from '@/lib/api/locations';
+import { queryKeys } from '../keys';
+
+export function useLocations() {
+  return useQuery<Location[]>({
+    queryKey: queryKeys.locations.list(),
+    queryFn: () => locationApiClient.getLocations(),
+  });
+}
+
+export function useCreateLocation() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CreateLocationInput) => locationApiClient.createLocation(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.locations.all });
+    },
+  });
+}
+
+export function useUpdateLocation() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: UpdateLocationInput }) =>
+      locationApiClient.updateLocation(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.locations.all });
+    },
+  });
+}
+
+export function useDeleteLocation() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => locationApiClient.deleteLocation(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.locations.all });
+    },
+  });
+}
diff --git a/frontend/lib/query/hooks/useMaintenance.ts b/frontend/lib/query/hooks/useMaintenance.ts
new file mode 100644
index 000000000..af3a5c0ce
--- /dev/null
+++ b/frontend/lib/query/hooks/useMaintenance.ts
@@ -0,0 +1,57 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  maintenanceApiClient,
+  CreateMaintenanceRecordInput,
+  MaintenanceFilters,
+  MaintenanceRecord,
+  MaintenanceStatus,
+} from '@/lib/api/maintenance';
+import { queryKeys } from '../keys';
+
+export function useMaintenanceRecords(filters?: MaintenanceFilters) {
+  return useQuery<MaintenanceRecord[]>({
+    queryKey: queryKeys.maintenance.list(filters as Record<string, unknown>),
+    queryFn: () => maintenanceApiClient.getMaintenanceRecords(filters),
+  });
+}
+
+export function useCreateMaintenanceRecord() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: CreateMaintenanceRecordInput) =>
+      maintenanceApiClient.createMaintenanceRecord(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.maintenance.all });
+    },
+  });
+}
+
+export function useUpdateMaintenanceStatus() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, status }: { id: string; status: MaintenanceStatus }) =>
+      maintenanceApiClient.updateMaintenanceStatus(id, status),
+    onMutate: async ({ id, status }) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.maintenance.all });
+      const previous = queryClient.getQueriesData<MaintenanceRecord[]>({
+        queryKey: queryKeys.maintenance.all,
+      });
+      previous.forEach(([key, records]) => {
+        if (!records) return;
+        queryClient.setQueryData<MaintenanceRecord[]>(
+          key,
+          records.map((r) => (r.id === id ? { ...r, status } : r)),
+        );
+      });
+      return { previous };
+    },
+    onError: (_err, _vars, context) => {
+      context?.previous?.forEach(([key, records]) => {
+        queryClient.setQueryData(key, records);
+      });
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.maintenance.all });
+    },
+  });
+}
diff --git a/frontend/lib/query/keys.ts b/frontend/lib/query/keys.ts
index 357ff98bc..f6eb666d1 100644
--- a/frontend/lib/query/keys.ts
+++ b/frontend/lib/query/keys.ts
@@ -35,4 +35,26 @@ export const queryKeys = {
     all: ['reports'] as const,
     summary: () => [...queryKeys.reports.all, 'summary'] as const,
   },
+  locations: {
+    all: ['locations'] as const,
+    list: () => [...queryKeys.locations.all, 'list'] as const,
+    detail: (id: string) => [...queryKeys.locations.all, 'detail', id] as const,
+  },
+  licenses: {
+    all: ['licenses'] as const,
+    list: () => [...queryKeys.licenses.all, 'list'] as const,
+    detail: (id: string) => [...queryKeys.licenses.all, 'detail', id] as const,
+    assignments: (id: string) => [...queryKeys.licenses.detail(id), 'assignments'] as const,
+  },
+  maintenance: {
+    all: ['maintenance'] as const,
+    list: (filters?: Record<string, unknown>) =>
+      [...queryKeys.maintenance.all, 'list', filters ?? {}] as const,
+    detail: (id: string) => [...queryKeys.maintenance.all, 'detail', id] as const,
+  },
+  audits: {
+    all: ['audits'] as const,
+    list: () => [...queryKeys.audits.all, 'list'] as const,
+    detail: (id: string) => [...queryKeys.audits.all, 'detail', id] as const,
+  },
 } as const;
\ No newline at end of file
diff --git a/frontend/lib/query/types/asset.ts b/frontend/lib/query/types/asset.ts
index 7ed789e4b..e67dec61c 100644
--- a/frontend/lib/query/types/asset.ts
+++ b/frontend/lib/query/types/asset.ts
@@ -49,6 +49,7 @@ export interface Asset {
   condition: AssetCondition;
   department: Department;
   location: string | null;
+  locationId?: string | null;
   assignedTo: AssetUser | null;
   imageUrls: string[] | null;
   customFields: Record<string, unknown> | null;