diff --git a/appinfo/info.xml b/appinfo/info.xml
index 08e2c7f2b..73b023b6c 100644
--- a/appinfo/info.xml
+++ b/appinfo/info.xml
@@ -12,7 +12,7 @@
 Those groups of people can then be used by any other app for sharing purpose.
 		]]>
 	</description>
-	<version>36.0.0-dev.0</version>
+	<version>36.0.0-dev.1</version>
 	<licence>AGPL-3.0-or-later</licence>
 	<author>Maxence Lange</author>
 	<types>
diff --git a/appinfo/routes.php b/appinfo/routes.php
index ba43f0f51..5ae7dbd85 100644
--- a/appinfo/routes.php
+++ b/appinfo/routes.php
@@ -53,6 +53,9 @@
 		['name' => 'TeamFolder#getLinkableTeamFolders', 'url' => '/teams/{circleId}/folder/linkable', 'verb' => 'GET'],
 		['name' => 'TeamFolder#linkTeamFolder', 'url' => '/teams/{circleId}/folder/link', 'verb' => 'POST'],
 		['name' => 'TeamFolder#updateTeamFolderQuota', 'url' => '/teams/{circleId}/folder/quota', 'verb' => 'PUT'],
+		['name' => 'TeamFavorites#getFavorites', 'url' => '/teams/favorites', 'verb' => 'GET'],
+		['name' => 'TeamFavorites#setFavorite', 'url' => '/teams/{circleId}/favorite', 'verb' => 'PUT'],
+		['name' => 'TeamFavorites#reorder', 'url' => '/teams/favorites/order', 'verb' => 'PUT'],
 
 		// Teams Dashboard widget endpoint
 		['name' => 'TeamsDashboard#getCompleteTeamsData', 'url' => '/teams/dashboard/widget', 'verb' => 'GET'],
diff --git a/lib/Controller/TeamFavoritesController.php b/lib/Controller/TeamFavoritesController.php
new file mode 100644
index 000000000..ced460565
--- /dev/null
+++ b/lib/Controller/TeamFavoritesController.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Controller;
+
+use OCA\Circles\Service\TeamFavoriteService;
+use OCP\AppFramework\Http\Attribute\NoAdminRequired;
+use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\OCSController;
+use OCP\IRequest;
+
+class TeamFavoritesController extends OCSController {
+	public function __construct(
+		string $appName,
+		IRequest $request,
+		private readonly TeamFavoriteService $teamFavoriteService,
+	) {
+		parent::__construct($appName, $request);
+	}
+
+	#[NoAdminRequired]
+	public function getFavorites(): DataResponse {
+		return new DataResponse([
+			'circleIds' => $this->teamFavoriteService->getFavoriteCircleIds(),
+		]);
+	}
+
+	#[NoAdminRequired]
+	public function setFavorite(string $circleId, bool $isFavorite): DataResponse {
+		$circleIds = $this->teamFavoriteService->setFavorite($circleId, $isFavorite);
+
+		return new DataResponse([
+			'circleId' => $circleId,
+			'isFavorite' => $isFavorite,
+			'circleIds' => $circleIds,
+		]);
+	}
+
+	/**
+	 * @param list<string> $circleIds
+	 * @param list<string> $expectedCircleIds
+	 */
+	#[NoAdminRequired]
+	public function reorder(array $circleIds, array $expectedCircleIds): DataResponse {
+		return new DataResponse([
+			'circleIds' => $this->teamFavoriteService->reorder($circleIds, $expectedCircleIds),
+		]);
+	}
+}
diff --git a/lib/Db/CircleRequest.php b/lib/Db/CircleRequest.php
index 99436aba0..93ff586c2 100644
--- a/lib/Db/CircleRequest.php
+++ b/lib/Db/CircleRequest.php
@@ -21,6 +21,9 @@
 use OCA\Circles\Model\Member;
 use OCA\Circles\Model\Probes\CircleProbe;
 use OCA\Circles\Model\Probes\DataProbe;
+use OCA\Circles\Repository\TeamFavoriteRepository;
+use OCA\Circles\Service\ConfigService;
+use OCA\Circles\Service\TimezoneService;
 use OCP\DB\QueryBuilder\IQueryBuilder;
 
 /**
@@ -29,6 +32,14 @@
  * @package OCA\Circles\Db
  */
 class CircleRequest extends CircleRequestBuilder {
+	public function __construct(
+		private readonly TeamFavoriteRepository $teamFavoriteRepository,
+		TimezoneService $timezoneService,
+		ConfigService $configService,
+	) {
+		parent::__construct($timezoneService, $configService);
+	}
+
 	/**
 	 * @param Circle $circle
 	 *
@@ -523,6 +534,7 @@ public function delete(Circle $circle): void {
 		$qb->limitToUniqueId($circle->getSingleId());
 
 		$qb->executeStatement();
+		$this->teamFavoriteRepository->removeCircle($circle->getSingleId());
 	}
 
 	/**
diff --git a/lib/Entity/TeamFavorite.php b/lib/Entity/TeamFavorite.php
new file mode 100644
index 000000000..a73667d69
--- /dev/null
+++ b/lib/Entity/TeamFavorite.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Entity;
+
+use DateTime;
+use DateTimeZone;
+use OCP\AppFramework\ORM\Attribute\Column;
+use OCP\AppFramework\ORM\Attribute\Entity as EntityAttribute;
+use OCP\AppFramework\ORM\Attribute\Id;
+use OCP\DB\Schema\ColumnType;
+
+#[EntityAttribute(name: 'circles_team_favorites')]
+final class TeamFavorite {
+	#[Id]
+	#[Column(name: 'id', type: ColumnType::Integer)]
+	public ?int $id = null;
+
+	#[Column(name: 'user_id', type: ColumnType::String, length: 255)]
+	public string $userId = '';
+
+	#[Column(name: 'circle_id', type: ColumnType::String, length: 32)]
+	public string $circleId = '';
+
+	#[Column(name: 'position', type: ColumnType::Integer)]
+	public int $position = 0;
+
+	#[Column(name: 'created', type: ColumnType::Datetime)]
+	public DateTime $created;
+
+	public function __construct() {
+		$this->created = new DateTime('now', new DateTimeZone('UTC'));
+	}
+}
diff --git a/lib/Listeners/UserDeleted.php b/lib/Listeners/UserDeleted.php
index 2cfee73e2..e7e906d25 100644
--- a/lib/Listeners/UserDeleted.php
+++ b/lib/Listeners/UserDeleted.php
@@ -10,6 +10,7 @@
 namespace OCA\Circles\Listeners;
 
 use Exception;
+use OCA\Circles\Repository\TeamFavoriteRepository;
 use OCA\Circles\Service\SyncService;
 use OCP\EventDispatcher\Event;
 use OCP\EventDispatcher\IEventListener;
@@ -24,6 +25,7 @@ class UserDeleted implements IEventListener {
 	 */
 	public function __construct(
 		private readonly SyncService $syncService,
+		private readonly TeamFavoriteRepository $teamFavoriteRepository,
 	) {
 	}
 
@@ -36,6 +38,7 @@ public function handle(Event $event): void {
 		}
 
 		$user = $event->getUser();
+		$this->teamFavoriteRepository->removeUser($user->getUID());
 
 		try {
 			$this->syncService->userDeleted($user->getUID());
diff --git a/lib/Migration/Version20260922120000.php b/lib/Migration/Version20260922120000.php
new file mode 100644
index 000000000..a5c723f2b
--- /dev/null
+++ b/lib/Migration/Version20260922120000.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Migration;
+
+use Closure;
+use OCP\DB\ISchemaWrapper;
+use OCP\DB\Schema\ColumnType;
+use OCP\DB\Schema\SchemaException;
+use OCP\Migration\IOutput;
+use OCP\Migration\SimpleMigrationStep;
+
+class Version20260922120000 extends SimpleMigrationStep {
+	/**
+	 * @param IOutput $output
+	 * @param Closure $schemaClosure The closure returns a schema wrapper.
+	 * @param array $options
+	 *
+	 * @throws SchemaException
+	 */
+	public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper {
+		/** @var ISchemaWrapper $schema */
+		$schema = $schemaClosure();
+
+		if (!$schema->hasTable('circles_team_favorites')) {
+			$table = $schema->createTable('circles_team_favorites');
+			$table->addColumn('id', ColumnType::Integer, [
+				'autoincrement' => true,
+				'notnull' => true,
+				'length' => 8,
+				'unsigned' => true,
+			]);
+			$table->addColumn('user_id', ColumnType::String, [
+				'length' => 255,
+				'notnull' => true,
+			]);
+			$table->addColumn('circle_id', ColumnType::String, [
+				'length' => 32,
+				'notnull' => true,
+			]);
+			$table->addColumn('position', ColumnType::Integer, [
+				'notnull' => true,
+				'unsigned' => true,
+			]);
+			$table->addColumn('created', ColumnType::Datetime, [
+				'notnull' => true,
+			]);
+
+			$table->setPrimaryKey(['id']);
+			$table->addUniqueIndex(['user_id', 'circle_id']);
+			$table->addIndex(['user_id', 'position']);
+			$table->addIndex(['circle_id']);
+		}
+
+		return $schema;
+	}
+}
diff --git a/lib/Repository/TeamFavoriteRepository.php b/lib/Repository/TeamFavoriteRepository.php
new file mode 100644
index 000000000..79e588321
--- /dev/null
+++ b/lib/Repository/TeamFavoriteRepository.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Repository;
+
+use OCA\Circles\Entity\TeamFavorite;
+use OCP\AppFramework\ORM\Repository;
+
+/**
+ * @extends Repository<TeamFavorite>
+ */
+class TeamFavoriteRepository extends Repository {
+	public const string entityClass = TeamFavorite::class;
+
+	/**
+	 * @return list<string>
+	 */
+	public function getCircleIds(string $userId, bool $accessibleOnly = false): array {
+		$qb = $this->connection->getQueryBuilder();
+		$qb->selectDistinct(['favorite.circle_id', 'favorite.position'])
+			->from($this->getTableName(), 'favorite')
+			->where($qb->expr()->eq('favorite.user_id', $qb->createNamedParameter($userId)));
+
+		if ($accessibleOnly) {
+			$expr = $qb->expr();
+			$qb->innerJoin('favorite', 'circles_member', 'user_member',
+				$expr->eq('user_member.user_id', 'favorite.user_id'));
+			$qb->leftJoin('user_member', 'circles_membership', 'membership', $expr->andX(
+				$expr->eq('membership.single_id', 'user_member.single_id'),
+				$expr->eq('membership.circle_id', 'favorite.circle_id'),
+			));
+			$qb->leftJoin('membership', 'circles_member', 'inherited_member', $expr->andX(
+				$expr->eq('inherited_member.single_id', 'membership.inheritance_first'),
+				$expr->eq('inherited_member.circle_id', 'favorite.circle_id'),
+			));
+			$qb->andWhere($expr->orX(
+				$expr->eq('user_member.circle_id', 'favorite.circle_id'),
+				$expr->isNotNull('inherited_member.single_id'),
+			));
+		}
+
+		$qb->orderBy('favorite.position', 'ASC')
+			->addOrderBy('favorite.circle_id', 'ASC');
+
+		$result = $qb->executeQuery();
+		$circleIds = [];
+		while ($row = $result->fetch()) {
+			$circleIds[] = $row['circle_id'];
+		}
+		$result->closeCursor();
+
+		return $circleIds;
+	}
+
+	public function add(string $userId, string $circleId): void {
+		$last = iterator_to_array($this->findBy(
+			['userId' => $userId],
+			['position' => \SortDirection::Descending],
+			1,
+		), false);
+
+		$favorite = new TeamFavorite();
+		$favorite->userId = $userId;
+		$favorite->circleId = $circleId;
+		$favorite->position = $last === [] ? 0 : $last[0]->position + 1;
+		$this->insert($favorite);
+	}
+
+	public function remove(string $userId, string $circleId): void {
+		$this->deleteBy(['userId' => $userId, 'circleId' => $circleId]);
+	}
+
+	/**
+	 * @param list<string> $circleIds
+	 */
+	public function replaceOrder(string $userId, array $circleIds): void {
+		$positions = array_flip($circleIds);
+		$this->connection->beginTransaction();
+		try {
+			foreach ($this->findBy(['userId' => $userId]) as $favorite) {
+				if (!isset($positions[$favorite->circleId])) {
+					continue;
+				}
+				$favorite->position = $positions[$favorite->circleId];
+				$this->update($favorite);
+			}
+			$this->connection->commit();
+		} catch (\Throwable $exception) {
+			$this->connection->rollBack();
+			throw $exception;
+		}
+	}
+
+	public function removeCircle(string $circleId): void {
+		$this->deleteBy(['circleId' => $circleId]);
+	}
+
+	public function removeUser(string $userId): void {
+		$this->deleteBy(['userId' => $userId]);
+	}
+}
diff --git a/lib/Service/TeamFavoriteService.php b/lib/Service/TeamFavoriteService.php
new file mode 100644
index 000000000..25cae6fe0
--- /dev/null
+++ b/lib/Service/TeamFavoriteService.php
@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Service;
+
+use OCA\Circles\Exceptions\InsufficientPermissionException;
+use OCA\Circles\Repository\TeamFavoriteRepository;
+use OCP\AppFramework\Http;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\IUserSession;
+use OCP\Lock\ILockingProvider;
+use OCP\Lock\LockedException;
+
+class TeamFavoriteService {
+	public function __construct(
+		private readonly TeamFavoriteRepository $teamFavoriteRepository,
+		private readonly PermissionService $permissionService,
+		private readonly IUserSession $userSession,
+		private readonly ILockingProvider $lockingProvider,
+	) {
+	}
+
+	/**
+	 * @return list<string>
+	 */
+	public function getFavoriteCircleIds(): array {
+		return $this->teamFavoriteRepository->getCircleIds($this->getCurrentUserId(), true);
+	}
+
+	/**
+	 * @return list<string>
+	 */
+	public function setFavorite(string $circleId, bool $isFavorite): array {
+		$userId = $this->getCurrentUserId();
+		$lock = $this->acquireLock($userId);
+		try {
+			$favoriteCircleIds = $this->pruneFavorites($userId);
+			if (!$isFavorite) {
+				$this->teamFavoriteRepository->remove($userId, $circleId);
+			} elseif (!in_array($circleId, $favoriteCircleIds, true)) {
+				try {
+					$this->permissionService->userMustBeMember($userId, $circleId);
+				} catch (InsufficientPermissionException $exception) {
+					throw new OCSException($exception->getMessage(), Http::STATUS_FORBIDDEN);
+				}
+				$this->teamFavoriteRepository->add($userId, $circleId);
+			}
+			return $this->teamFavoriteRepository->getCircleIds($userId, true);
+		} finally {
+			$this->lockingProvider->releaseLock($lock, ILockingProvider::LOCK_EXCLUSIVE);
+		}
+	}
+
+	/**
+	 * @param list<string> $circleIds
+	 * @param list<string> $expectedCircleIds
+	 * @return list<string>
+	 */
+	public function reorder(array $circleIds, array $expectedCircleIds): array {
+		foreach ([$circleIds, $expectedCircleIds] as $ids) {
+			if (!array_is_list($ids) || array_filter($ids, 'is_string') !== $ids
+				|| count($ids) !== count(array_unique($ids))) {
+				throw new OCSException('Invalid favorite team order.', Http::STATUS_BAD_REQUEST);
+			}
+		}
+		if (count($circleIds) !== count($expectedCircleIds) || array_diff($circleIds, $expectedCircleIds) !== []) {
+			throw new OCSException('Invalid favorite team order.', Http::STATUS_BAD_REQUEST);
+		}
+		$userId = $this->getCurrentUserId();
+		$lock = $this->acquireLock($userId);
+		try {
+			$currentCircleIds = $this->pruneFavorites($userId);
+			if ($expectedCircleIds !== $currentCircleIds) {
+				throw new OCSException('Favorite teams have changed. Reload before reordering.', Http::STATUS_CONFLICT);
+			}
+			if ($circleIds !== $currentCircleIds) {
+				$this->teamFavoriteRepository->replaceOrder($userId, $circleIds);
+			}
+			return $this->teamFavoriteRepository->getCircleIds($userId, true);
+		} finally {
+			$this->lockingProvider->releaseLock($lock, ILockingProvider::LOCK_EXCLUSIVE);
+		}
+	}
+
+	/**
+	 * @return list<string>
+	 */
+	private function pruneFavorites(string $userId): array {
+		$stored = $this->teamFavoriteRepository->getCircleIds($userId);
+		$accessible = $this->teamFavoriteRepository->getCircleIds($userId, true);
+		foreach (array_diff($stored, $accessible) as $circleId) {
+			$this->teamFavoriteRepository->remove($userId, $circleId);
+		}
+		return $accessible;
+	}
+
+	private function acquireLock(string $userId): string {
+		$lock = 'circles:team-favorites:' . hash('sha256', $userId);
+		try {
+			$this->lockingProvider->acquireLock($lock, ILockingProvider::LOCK_EXCLUSIVE);
+		} catch (LockedException) {
+			throw new OCSException('Favorite teams are being updated. Please retry.', Http::STATUS_CONFLICT);
+		}
+		return $lock;
+	}
+
+	private function getCurrentUserId(): string {
+		$user = $this->userSession->getUser();
+		if ($user === null) {
+			throw new OCSException('No authenticated user.', Http::STATUS_UNAUTHORIZED);
+		}
+
+		return $user->getUID();
+	}
+}
diff --git a/src/teams/api.spec.ts b/src/teams/api.spec.ts
index 44e0609f2..e85ec1408 100644
--- a/src/teams/api.spec.ts
+++ b/src/teams/api.spec.ts
@@ -32,7 +32,7 @@ vi.mock('./team-page/services/collaborationAutocompletion.js', () => ({
 	getSuggestions: vi.fn(),
 }))
 
-const { createTeam, fetchTeams } = await import('./api.ts')
+const { createTeam, fetchTeams, setTeamFavorite, reorderFavoriteTeams } = await import('./api.ts')
 
 describe('fetchTeams', () => {
 	it('drops circles the current user is not a member of', async () => {
@@ -43,6 +43,7 @@ describe('fetchTeams', () => {
 		vi.mocked(axios.get)
 			.mockResolvedValueOnce({ data: { ocs: { data: circles } } })
 			.mockResolvedValueOnce({ data: { ocs: { data: [] } } })
+			.mockResolvedValueOnce({ data: { ocs: { data: { circleIds: [] } } } })
 
 		const teams = await fetchTeams()
 
@@ -55,6 +56,7 @@ describe('fetchTeams', () => {
 		vi.mocked(axios.get)
 			.mockResolvedValueOnce({ data: { ocs: {} } })
 			.mockResolvedValueOnce({ data: { ocs: { data: [] } } })
+			.mockResolvedValueOnce({ data: { ocs: { data: { circleIds: [] } } } })
 
 		await expect(fetchTeams()).resolves.toEqual([])
 	})
@@ -85,3 +87,30 @@ describe('createTeam', () => {
 		)
 	})
 })
+
+describe('favorite teams API', () => {
+	beforeEach(() => vi.resetAllMocks())
+
+	it('returns the canonical favorite list after a toggle', async () => {
+		vi.mocked(axios.put).mockResolvedValue({ data: { ocs: { data: { circleIds: ['A', 'B'] } } } })
+		expect(await setTeamFavorite('B', true)).toEqual(['A', 'B'])
+		expect(axios.put).toHaveBeenCalledWith(expect.stringContaining('/favorite'), { isFavorite: true })
+	})
+
+	it('includes the expected order and reads the canonical response', async () => {
+		vi.mocked(axios.put).mockResolvedValue({ data: { ocs: { data: { circleIds: ['B', 'A'] } } } })
+		expect(await reorderFavoriteTeams(['B', 'A'], ['A', 'B'])).toEqual(['B', 'A'])
+		expect(axios.put).toHaveBeenCalledWith('/ocs/apps/circles/teams/favorites/order', {
+			circleIds: ['B', 'A'],
+			expectedCircleIds: ['A', 'B'],
+		})
+	})
+
+	it('still loads teams when favorites cannot be read', async () => {
+		vi.mocked(axios.get).mockResolvedValueOnce({ data: { ocs: { data: [{ id: 'A', name: 'A', displayName: 'A', initiator: { level: 1 } }] } } })
+			.mockResolvedValueOnce({ data: { ocs: { data: [] } } })
+			.mockRejectedValueOnce(new Error('favorites unavailable'))
+		const teams = await fetchTeams()
+		expect(teams.map((team) => [team.id, team.isFavorite])).toEqual([['A', false]])
+	})
+})
diff --git a/src/teams/api.ts b/src/teams/api.ts
index 9de42fae6..f5d66fe7d 100644
--- a/src/teams/api.ts
+++ b/src/teams/api.ts
@@ -140,9 +140,10 @@ function mapFullMember(raw: RawMember): Member {
  * description, member count, our role) with the members preview and resources.
  */
 export async function fetchTeams(): Promise<Team[]> {
-	const [circlesRes, dashRes] = await Promise.allSettled([
+	const [circlesRes, dashRes, favoritesRes] = await Promise.allSettled([
 		axios.get<OcsResponse<RawCircle[]>>(generateOcsUrl('apps/circles/circles') + '?limit=-1'),
 		axios.get<OcsResponse<RawDashboardTeam[]>>(generateOcsUrl('apps/circles/teams/dashboard/widget') + '?limit=200&offset=0'),
+		axios.get<OcsResponse<{ circleIds: string[] }>>(generateOcsUrl('apps/circles/teams/favorites')),
 	])
 
 	// The team list is required; without it we have nothing to show.
@@ -160,6 +161,13 @@ export async function fetchTeams(): Promise<Team[]> {
 		logger.warn('Failed to load team dashboard previews', { error: dashRes.reason })
 	}
 	const dashboardById = new Map(dashboard.map((team) => [team.singleId, team]))
+	let favoriteCircleIds: string[] = []
+	if (favoritesRes.status === 'fulfilled') {
+		favoriteCircleIds = favoritesRes.value.data.ocs.data.circleIds
+	} else {
+		logger.warn('Failed to load favorite teams', { error: favoritesRes.reason })
+	}
+	const favoritePositions = new Map(favoriteCircleIds.map((circleId, position) => [circleId, position]))
 
 	return circles.map((circle) => {
 		const extra = dashboardById.get(circle.id)
@@ -167,6 +175,8 @@ export async function fetchTeams(): Promise<Team[]> {
 			id: circle.id,
 			displayName: circle.displayName || circle.name,
 			description: circle.description ?? '',
+			isFavorite: favoritePositions.has(circle.id),
+			favoritePosition: favoritePositions.get(circle.id) ?? null,
 			memberCount: circle.population ?? extra?.members.length ?? 0,
 			myRole: levelToRole(circle.initiator?.level),
 			members: (extra?.members ?? []).map(mapPreviewMember),
@@ -175,6 +185,28 @@ export async function fetchTeams(): Promise<Team[]> {
 	})
 }
 
+/**
+ * Update a favorite and return the canonical order.
+ *
+ * @param teamId - Team identifier
+ * @param isFavorite - Desired favorite state
+ */
+export async function setTeamFavorite(teamId: string, isFavorite: boolean): Promise<string[]> {
+	const response = await axios.put<OcsResponse<{ circleIds: string[] }>>(generateOcsUrl('apps/circles/teams/{circleId}/favorite', { circleId: teamId }), { isFavorite })
+	return response.data.ocs.data.circleIds
+}
+
+/**
+ * Save a new order only if the server still has the expected order.
+ *
+ * @param teamIds - Desired order
+ * @param expectedCircleIds - Previously loaded order
+ */
+export async function reorderFavoriteTeams(teamIds: string[], expectedCircleIds: string[]): Promise<string[]> {
+	const response = await axios.put<OcsResponse<{ circleIds: string[] }>>(generateOcsUrl('apps/circles/teams/favorites/order'), { circleIds: teamIds, expectedCircleIds })
+	return response.data.ocs.data.circleIds
+}
+
 /**
  * Fetch the full member list for a team (includes roles).
  *
diff --git a/src/teams/components/TeamAvatar.vue b/src/teams/components/TeamAvatar.vue
index 9e549999a..88a84010a 100644
--- a/src/teams/components/TeamAvatar.vue
+++ b/src/teams/components/TeamAvatar.vue
@@ -35,6 +35,7 @@ export function getAvatarUrl(circleId: string): string {
 </script>
 
 <script setup lang="ts">
+import { mdiStar } from '@mdi/js'
 import { computed } from 'vue'
 import NcAvatar from '@nextcloud/vue/components/NcAvatar'
 
@@ -42,20 +43,52 @@ const props = withDefaults(defineProps<{
 	displayName: string
 	circleId: string
 	size?: number
+	isFavorite?: boolean
 }>(), {
 	size: 32,
+	isFavorite: false,
 })
 
 const avatarUrl = computed(() => getAvatarUrl(props.circleId))
 </script>
 
 <template>
-	<NcAvatar
-		:displayName="displayName"
-		:url="avatarUrl"
-		:isNoUser="true"
-		:size="size"
-		hideStatus
-		disableMenu
-		disableTooltip />
+	<span class="team-avatar">
+		<NcAvatar
+			:displayName="displayName"
+			:url="avatarUrl"
+			:isNoUser="true"
+			:size="size"
+			hideStatus
+			disableMenu
+			disableTooltip />
+		<svg
+			v-if="isFavorite"
+			class="team-avatar__favorite"
+			viewBox="0 0 24 24"
+			aria-hidden="true">
+			<path :d="mdiStar" />
+		</svg>
+	</span>
 </template>
+
+<style lang="scss" scoped>
+.team-avatar {
+	position: relative;
+	display: inline-flex;
+	flex: 0 0 auto;
+
+	&__favorite {
+		position: absolute;
+		right: -2px;
+		bottom: -2px;
+		width: 12px;
+		height: 12px;
+		padding: 1px;
+		border-radius: 50%;
+		background-color: var(--color-main-background);
+		fill: var(--color-element-warning, #c88800);
+		pointer-events: none;
+	}
+}
+</style>
diff --git a/src/teams/components/TeamCard.spec.ts b/src/teams/components/TeamCard.spec.ts
new file mode 100644
index 000000000..b47484faf
--- /dev/null
+++ b/src/teams/components/TeamCard.spec.ts
@@ -0,0 +1,155 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Team } from '../types.ts'
+
+import { shallowMount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import TeamCard from './TeamCard.vue'
+
+// @nextcloud/vue pulls RTL helpers from the same module, so keep the rest.
+vi.mock('@nextcloud/l10n', async (importOriginal) => ({
+	...(await importOriginal<object>()),
+	t: (app: string, text: string) => text,
+}))
+
+function makeTeam(overrides: Partial<Team> = {}): Team {
+	return {
+		id: 'team1',
+		displayName: 'Team One',
+		description: 'A team',
+		isFavorite: false,
+		favoritePosition: null,
+		memberCount: 2,
+		myRole: 'member',
+		members: [
+			{ id: 'm1', userId: 'alice', displayName: 'Alice', isUser: true, role: 'member' },
+			{ id: 'm2', userId: 'bob', displayName: 'Bob', isUser: true, role: 'member' },
+		],
+		resources: [],
+		...overrides,
+	}
+}
+
+function mountCard(props: Record<string, unknown> = {}, team: Team = makeTeam()) {
+	return shallowMount(TeamCard, {
+		props: { team, ...props },
+		global: {
+			// Render slots of stubbed components so actions and links stay reachable.
+			renderStubDefaultSlot: true,
+			stubs: { RouterLink: { template: '<a><slot /></a>' } },
+		},
+	})
+}
+
+function actionButtons(wrapper: ReturnType<typeof mountCard>) {
+	return wrapper.findAllComponents({ name: 'NcActionButton' })
+}
+
+describe('TeamCard actions', () => {
+	it('only offers the favorite action when the card is not sortable', () => {
+		const buttons = actionButtons(mountCard())
+
+		expect(buttons).toHaveLength(1)
+	})
+
+	it('offers move up, move down and favorite when sortable', () => {
+		const buttons = actionButtons(mountCard({ sortable: true }))
+
+		expect(buttons).toHaveLength(3)
+	})
+
+	it('emits toggleFavorite with the team', () => {
+		const team = makeTeam()
+		const wrapper = mountCard({}, team)
+
+		actionButtons(wrapper)[0].vm.$emit('click')
+
+		expect(wrapper.emitted('toggleFavorite')).toEqual([[team]])
+	})
+
+	it('emits moveUp and moveDown with the team', () => {
+		const team = makeTeam({ isFavorite: true })
+		const wrapper = mountCard({ sortable: true, canMoveUp: true, canMoveDown: true }, team)
+		const [up, down] = actionButtons(wrapper)
+
+		up.vm.$emit('click')
+		down.vm.$emit('click')
+
+		expect(wrapper.emitted('moveUp')).toEqual([[team]])
+		expect(wrapper.emitted('moveDown')).toEqual([[team]])
+	})
+
+	it('disables moving beyond the ends of the list', () => {
+		const [up, down] = actionButtons(mountCard({ sortable: true, canMoveUp: false, canMoveDown: true }))
+
+		expect(up.props('disabled')).toBe(true)
+		expect(down.props('disabled')).toBe(false)
+	})
+
+	it('disables every action while a favorite update is running', () => {
+		const buttons = actionButtons(mountCard({ sortable: true, canMoveUp: true, canMoveDown: true, favoriteBusy: true }))
+
+		expect(buttons.map((button) => button.props('disabled'))).toEqual([true, true, true])
+	})
+})
+
+describe('TeamCard dragging', () => {
+	it('is draggable only when requested', () => {
+		expect(mountCard({ draggable: true }).get('article').attributes('draggable')).toBe('true')
+		expect(mountCard({ draggable: false }).get('article').attributes('draggable')).toBe('false')
+	})
+
+	it('forwards drag events with the team', async () => {
+		const team = makeTeam({ isFavorite: true })
+		const wrapper = mountCard({ draggable: true }, team)
+		const article = wrapper.get('article')
+
+		await article.trigger('dragstart')
+		await article.trigger('dragover')
+		await article.trigger('dragend')
+
+		expect(wrapper.emitted('dragStart')?.[0][0]).toEqual(team)
+		expect(wrapper.emitted('dragOver')?.[0][0]).toEqual(team)
+		expect(wrapper.emitted('dragEnd')).toHaveLength(1)
+	})
+})
+
+describe('TeamCard content', () => {
+	it('uses one team link for all card content', () => {
+		const links = mountCard().findAll('a')
+
+		expect(links).toHaveLength(1)
+		expect(links[0].text()).toContain('Team One')
+	})
+
+	it('shows the description only when there is one', () => {
+		expect(mountCard().text()).toContain('A team')
+		expect(mountCard({}, makeTeam({ description: '' })).find('p').exists()).toBe(false)
+	})
+
+	it('shows how many members are not part of the preview', () => {
+		const wrapper = mountCard({}, makeTeam({ memberCount: 9 }))
+
+		expect(wrapper.text()).toContain('+7')
+	})
+
+	it('shows no overflow counter when all members are previewed', () => {
+		expect(mountCard().text()).not.toContain('+')
+	})
+
+	it('previews at most five members', () => {
+		const members = Array.from({ length: 8 }, (_, index): Team['members'][number] => ({
+			id: `m${index}`,
+			userId: `user${index}`,
+			displayName: `User ${index}`,
+			isUser: true,
+			role: 'member',
+		}))
+		const wrapper = mountCard({}, makeTeam({ members, memberCount: 8 }))
+
+		expect(wrapper.findAllComponents({ name: 'NcAvatar' })).toHaveLength(5)
+	})
+})
diff --git a/src/teams/components/TeamCard.vue b/src/teams/components/TeamCard.vue
index 4d05f3883..792aeceda 100644
--- a/src/teams/components/TeamCard.vue
+++ b/src/teams/components/TeamCard.vue
@@ -6,57 +6,141 @@
 <script setup lang="ts">
 import type { Team } from '../types.ts'
 
+import { mdiArrowDown, mdiArrowUp, mdiStar, mdiStarOutline } from '@mdi/js'
 import { t } from '@nextcloud/l10n'
+import NcActionButton from '@nextcloud/vue/components/NcActionButton'
+import NcActions from '@nextcloud/vue/components/NcActions'
 import NcAvatar from '@nextcloud/vue/components/NcAvatar'
+import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
 import TeamAvatar from './TeamAvatar.vue'
 
-const props = defineProps<{
+const props = withDefaults(defineProps<{
 	team: Team
+	draggable?: boolean
+	favoriteBusy?: boolean
+	/** Whether this card is part of a manually sortable list (the favorites). */
+	sortable?: boolean
+	canMoveUp?: boolean
+	canMoveDown?: boolean
+}>(), {
+	sortable: false,
+	canMoveUp: false,
+	canMoveDown: false,
+})
+
+const emit = defineEmits<{
+	toggleFavorite: [team: Team]
+	moveUp: [team: Team]
+	moveDown: [team: Team]
+	dragStart: [team: Team, event: DragEvent]
+	dragOver: [team: Team, event: DragEvent]
+	dragEnd: [event: DragEvent]
 }>()
 
 const MAX_AVATARS = 5
+
+/** Toggle the favorite without starting a drag. */
+function toggleFavorite() {
+	emit('toggleFavorite', props.team)
+}
+
+/**
+ * Keep action buttons out of native card dragging.
+ *
+ * @param event - Native drag event
+ */
+function preventActionsDrag(event: DragEvent) {
+	event.preventDefault()
+}
 </script>
 
 <template>
-	<RouterLink
+	<article
 		:class="$style.teamCard"
-		:to="{ name: 'team', params: { teamId: props.team.id } }">
-		<div :class="$style.teamCardHead">
-			<TeamAvatar
-				:displayName="team.displayName"
-				:circleId="team.id"
-				:size="44" />
-			<span :class="$style.teamCardName">{{ team.displayName }}</span>
-		</div>
+		:draggable="draggable"
+		@dragstart="emit('dragStart', team, $event)"
+		@dragover="emit('dragOver', team, $event)"
+		@dragend="emit('dragEnd', $event)">
+		<RouterLink
+			:class="$style.teamCardLink"
+			:to="{ name: 'team', params: { teamId: props.team.id } }">
+			<div :class="$style.teamCardHead">
+				<TeamAvatar
+					:circleId="team.id"
+					:displayName="team.displayName"
+					:isFavorite="team.isFavorite"
+					:size="40" />
+				<span :class="$style.teamCardName">
+					{{ team.displayName }}
+				</span>
+			</div>
+			<p v-if="team.description" :class="$style.teamCardDescription">
+				{{ team.description }}
+			</p>
 
-		<p v-if="team.description" :class="$style.teamCardDescription">
-			{{ team.description }}
-		</p>
-
-		<div :class="$style.teamCardFooter">
-			<ul :class="$style.teamCardMembers" :aria-label="t('circles', 'Members')">
-				<li
-					v-for="member in team.members.slice(0, MAX_AVATARS)"
-					:key="member.id"
-					:class="$style.teamCardMember">
-					<NcAvatar
-						:user="member.isUser ? member.userId ?? undefined : undefined"
-						:displayName="member.displayName"
-						:isNoUser="!member.isUser"
-						:size="28"
-						hideStatus
-						disableMenu />
-				</li>
-				<li v-if="team.memberCount > team.members.length" :class="$style.teamCardMemberMore">
-					+{{ team.memberCount - team.members.length }}
-				</li>
-			</ul>
+			<div :class="$style.teamCardFooter">
+				<ul :class="$style.teamCardMembers" :aria-label="t('circles', 'Members')">
+					<li
+						v-for="member in team.members.slice(0, MAX_AVATARS)"
+						:key="member.id"
+						:class="$style.teamCardMember">
+						<NcAvatar
+							:user="member.isUser ? member.userId ?? undefined : undefined"
+							:displayName="member.displayName"
+							:isNoUser="!member.isUser"
+							:size="28"
+							hideStatus
+							disableMenu />
+					</li>
+					<li v-if="team.memberCount > team.members.length" :class="$style.teamCardMemberMore">
+						+{{ team.memberCount - team.members.length }}
+					</li>
+				</ul>
+			</div>
+		</RouterLink>
+		<div :class="$style.teamCardActions" @mousedown.stop @dragstart.prevent.stop>
+			<NcActions
+				:class="$style.teamCardActionsMenu"
+				draggable="false"
+				:aria-label="t('circles', 'Team actions')"
+				@dragstart="preventActionsDrag">
+				<NcActionButton
+					v-if="sortable"
+					:disabled="favoriteBusy || !canMoveUp"
+					closeAfterClick
+					@click="emit('moveUp', team)">
+					<template #icon>
+						<NcIconSvgWrapper :path="mdiArrowUp" :size="20" />
+					</template>
+					{{ t('circles', 'Move up') }}
+				</NcActionButton>
+				<NcActionButton
+					v-if="sortable"
+					:disabled="favoriteBusy || !canMoveDown"
+					closeAfterClick
+					@click="emit('moveDown', team)">
+					<template #icon>
+						<NcIconSvgWrapper :path="mdiArrowDown" :size="20" />
+					</template>
+					{{ t('circles', 'Move down') }}
+				</NcActionButton>
+				<NcActionButton
+					:disabled="favoriteBusy"
+					closeAfterClick
+					@click="toggleFavorite">
+					<template #icon>
+						<NcIconSvgWrapper :path="team.isFavorite ? mdiStar : mdiStarOutline" :size="20" />
+					</template>
+					{{ team.isFavorite ? t('circles', 'Remove from favorites') : t('circles', 'Add to favorites') }}
+				</NcActionButton>
+			</NcActions>
 		</div>
-	</RouterLink>
+	</article>
 </template>
 
 <style module lang="scss">
 .team-card {
+	position: relative;
 	display: flex;
 	flex-direction: column;
 	gap: calc(2 * var(--default-grid-baseline));
@@ -84,10 +168,48 @@ const MAX_AVATARS = 5
 		outline-offset: 2px;
 	}
 
+	&[draggable='true'] {
+		cursor: grab;
+	}
+
 	&__head {
 		display: flex;
 		align-items: center;
+		gap: var(--default-grid-baseline);
+	}
+
+	&__link {
+		display: flex;
+		flex: 1;
+		flex-direction: column;
 		gap: calc(2 * var(--default-grid-baseline));
+		min-width: 0;
+		color: inherit;
+		text-decoration: none;
+		cursor: pointer;
+
+		* {
+			cursor: pointer !important;
+		}
+	}
+
+	&__actions {
+		position: absolute;
+		inset-inline-end: calc(2 * var(--default-grid-baseline));
+		bottom: calc(3 * var(--default-grid-baseline) + 14px - var(--default-clickable-area) / 2);
+		display: flex;
+		align-items: center;
+	}
+
+	&__actions-menu {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+
+		&:disabled,
+		&:disabled * {
+			cursor: default !important;
+		}
 	}
 
 	&__name {
@@ -95,6 +217,9 @@ const MAX_AVATARS = 5
 		min-width: 0;
 		font-size: 1.1em;
 		font-weight: 600;
+		color: inherit;
+		text-decoration: none;
+		cursor: pointer;
 		// truncate long team names rather than wrap the header
 		overflow: hidden;
 		white-space: nowrap;
@@ -118,6 +243,7 @@ const MAX_AVATARS = 5
 		gap: calc(2 * var(--default-grid-baseline));
 		// push the footer down so equal-height cards align their footers
 		margin-top: auto;
+		padding-inline-end: calc(2 * var(--default-clickable-area));
 	}
 
 	&__members {
@@ -126,6 +252,8 @@ const MAX_AVATARS = 5
 		list-style: none;
 		padding: 0;
 		margin: 0;
+		min-width: 0;
+		flex-wrap: wrap;
 	}
 
 	// Each item overlaps the previous one to form a compact stack.
@@ -162,7 +290,7 @@ const MAX_AVATARS = 5
 		height: 28px;
 		padding-inline: 4px;
 		border-radius: 14px;
-		box-shadow: 0 0 0 2px var(--color-main-background);
+		cursor: pointer;
 		background-color: var(--color-background-dark);
 		color: var(--color-text-maxcontrast);
 		font-size: 0.8em;
diff --git a/src/teams/components/TeamHeader.vue b/src/teams/components/TeamHeader.vue
index 13bf66b43..f654cd408 100644
--- a/src/teams/components/TeamHeader.vue
+++ b/src/teams/components/TeamHeader.vue
@@ -7,7 +7,8 @@
 import type Circle from '../team-page/models/circle.ts'
 import type Member from '../team-page/models/member.ts'
 
-import { mdiChevronDown, mdiHomeOutline, mdiLinkVariant, mdiLogout, mdiMagnify, mdiPlus, mdiTrashCanOutline } from '@mdi/js'
+import { mdiChevronDown, mdiHomeOutline, mdiLinkVariant, mdiLogout, mdiMagnify, mdiPlus, mdiStar, mdiStarOutline, mdiTrashCanOutline } from '@mdi/js'
+import { showError } from '@nextcloud/dialogs'
 import { t } from '@nextcloud/l10n'
 import { useElementSize, useEventListener } from '@vueuse/core'
 import { computed, nextTick, ref, watch } from 'vue'
@@ -110,7 +111,17 @@ useEventListener(window, 'resize', () => {
 })
 
 // The current team is represented by the panel's header, not the list.
-const otherTeams = computed(() => teamsStore.teams.filter((item) => item.id !== props.circle.id))
+const otherTeams = computed(() => teamsStore.teams
+	.filter((item) => item.id !== props.circle.id)
+	.toSorted((left, right) => {
+		if (left.isFavorite !== right.isFavorite) {
+			return left.isFavorite ? -1 : 1
+		}
+		if (left.isFavorite) {
+			return (left.favoritePosition ?? 0) - (right.favoritePosition ?? 0)
+		}
+		return 0
+	}))
 
 // Teams list search: the "Go to team" caption row swaps for a text field
 // that filters the list; aborting the search restores the caption row.
@@ -168,6 +179,15 @@ async function openMembersPage(): Promise<void> {
 	await router.push({ name: 'team-members', params: { teamId: props.circle.id } })
 }
 
+/** Toggle the current team's favorite state and report failures. */
+async function onToggleFavorite(): Promise<void> {
+	try {
+		await teamsStore.toggleFavorite(props.circle.id)
+	} catch {
+		showError(t('circles', 'Could not update favorite team'))
+	}
+}
+
 </script>
 
 <template>
@@ -183,11 +203,14 @@ async function openMembersPage(): Promise<void> {
 					type="button"
 					class="team-header__trigger"
 					:title="t('circles', 'Switch team')"
-					:aria-label="t('circles', 'Switch team')"
+					:aria-label="team?.isFavorite
+						? t('circles', 'Switch team: {team} (favorite)', { team: circle.displayName })
+						: t('circles', 'Switch team: {team}', { team: circle.displayName })"
 					@click="switcherOpen = true">
 					<TeamAvatar
 						:displayName="circle.displayName"
 						:circleId="circle.id"
+						:isFavorite="team?.isFavorite"
 						:size="44" />
 
 					<span class="team-header__info">
@@ -218,6 +241,7 @@ async function openMembersPage(): Promise<void> {
 					<TeamAvatar
 						:displayName="circle.displayName"
 						:circleId="circle.id"
+						:isFavorite="team?.isFavorite"
 						:size="44" />
 
 					<div class="team-header__info">
@@ -242,6 +266,15 @@ async function openMembersPage(): Promise<void> {
 						v-if="team"
 						class="team-header__switcher-actions"
 						:aria-label="t('circles', 'Team actions')">
+						<NcActionButton
+							:disabled="teamsStore.favoritesUpdating"
+							closeAfterClick
+							@click="onToggleFavorite">
+							<template #icon>
+								<NcIconSvgWrapper :path="team.isFavorite ? mdiStar : mdiStarOutline" :size="20" />
+							</template>
+							{{ team.isFavorite ? t('circles', 'Remove from favorites') : t('circles', 'Add to favorites') }}
+						</NcActionButton>
 						<NcActionButton closeAfterClick @click="onCopyLink">
 							<template #icon>
 								<NcIconSvgWrapper :path="mdiLinkVariant" :size="20" />
@@ -305,12 +338,14 @@ async function openMembersPage(): Promise<void> {
 						:key="item.id"
 						:name="item.displayName"
 						:to="{ name: 'team', params: { teamId: item.id } }"
+						:linkAriaLabel="item.isFavorite ? t('circles', '{team} (favorite)', { team: item.displayName }) : item.displayName"
 						oneLine
 						@click="switcherOpen = false">
 						<template #icon>
 							<TeamAvatar
 								:displayName="item.displayName"
 								:circleId="item.id"
+								:isFavorite="item.isFavorite"
 								:size="32" />
 						</template>
 					</NcListItem>
diff --git a/src/teams/store.spec.ts b/src/teams/store.spec.ts
new file mode 100644
index 000000000..dee485953
--- /dev/null
+++ b/src/teams/store.spec.ts
@@ -0,0 +1,72 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Team } from './types.ts'
+
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import * as api from './api.ts'
+import { useTeamsStore } from './store.ts'
+
+vi.mock('./api.ts', () => ({ setTeamFavorite: vi.fn(), reorderFavoriteTeams: vi.fn(), fetchTeams: vi.fn() }))
+vi.mock('../logger.ts', () => ({ logger: { error: vi.fn() } }))
+
+function team(id: string, position: number | null): Team {
+	return { id, displayName: id, description: '', isFavorite: position !== null, favoritePosition: position, memberCount: 0, myRole: 'member', members: [], resources: [] }
+}
+
+describe('favorite teams', () => {
+	beforeEach(() => {
+		vi.resetAllMocks()
+		setActivePinia(createPinia())
+	})
+
+	it('normalizes positions after removal and appends new favorites', async () => {
+		const store = useTeamsStore()
+		store.teams = [team('D', null), team('A', 0), team('B', 1), team('C', 2)]
+		vi.mocked(api.setTeamFavorite).mockResolvedValueOnce(['B', 'C']).mockResolvedValueOnce(['B', 'C', 'D'])
+		await store.toggleFavorite('A')
+		await store.toggleFavorite('D')
+		expect(store.favoriteTeams.map((item) => item.id)).toEqual(['B', 'C', 'D'])
+		expect(store.favoriteTeams.map((item) => item.favoritePosition)).toEqual([0, 1, 2])
+	})
+
+	it('sends the last canonical order for conflict detection', async () => {
+		const store = useTeamsStore()
+		store.teams = [team('A', 0), team('B', 1)]
+		vi.mocked(api.reorderFavoriteTeams).mockResolvedValue(['B', 'A'])
+		await store.reorderFavoriteTeams(['B', 'A'])
+		expect(api.reorderFavoriteTeams).toHaveBeenCalledWith(['B', 'A'], ['A', 'B'])
+		expect(store.favoriteTeams.map((item) => item.id)).toEqual(['B', 'A'])
+	})
+
+	it('blocks overlapping favorite mutations', async () => {
+		const store = useTeamsStore()
+		store.teams = [team('A', null)]
+		let resolveRequest!: (ids: string[]) => void
+		vi.mocked(api.setTeamFavorite).mockReturnValue(new Promise((resolve) => {
+			resolveRequest = resolve
+		}))
+		const pending = store.toggleFavorite('A')
+		await store.toggleFavorite('A')
+		await store.reorderFavoriteTeams([])
+		expect(api.setTeamFavorite).toHaveBeenCalledTimes(1)
+		expect(api.reorderFavoriteTeams).not.toHaveBeenCalled()
+		expect(store.favoritesUpdating).toBe(true)
+		resolveRequest(['A'])
+		await pending
+		expect(store.favoritesUpdating).toBe(false)
+	})
+
+	it('reloads the server state on conflicts and releases the busy state', async () => {
+		const store = useTeamsStore()
+		store.teams = [team('A', 0), team('B', 1)]
+		vi.mocked(api.reorderFavoriteTeams).mockRejectedValue(new Error('conflict'))
+		vi.mocked(api.fetchTeams).mockResolvedValue([team('A', 0), team('B', 1), team('C', 2)])
+		await expect(store.reorderFavoriteTeams(['B', 'A'])).rejects.toThrow('conflict')
+		expect(store.favoriteTeams.map((item) => item.id)).toEqual(['A', 'B', 'C'])
+		expect(store.favoritesUpdating).toBe(false)
+	})
+})
diff --git a/src/teams/store.ts b/src/teams/store.ts
index b49b34605..16485bd93 100644
--- a/src/teams/store.ts
+++ b/src/teams/store.ts
@@ -18,6 +18,7 @@ interface TeamsState {
 	loadError: boolean
 	/** Whether the "create a new team" wizard is open (shared across the app). */
 	createWizardOpen: boolean
+	favoritesUpdating: boolean
 }
 
 /**
@@ -31,6 +32,7 @@ export const useTeamsStore = defineStore('teams', {
 		loading: false,
 		loadError: false,
 		createWizardOpen: false,
+		favoritesUpdating: false,
 	}),
 
 	getters: {
@@ -45,6 +47,10 @@ export const useTeamsStore = defineStore('teams', {
 			}
 			return state.teams.filter((team) => team.displayName.toLowerCase().includes(needle))
 		},
+
+		favoriteTeams: (state): Team[] => state.teams
+			.filter((team) => team.isFavorite)
+			.sort((left, right) => (left.favoritePosition ?? 0) - (right.favoritePosition ?? 0)),
 	},
 
 	actions: {
@@ -67,6 +73,61 @@ export const useTeamsStore = defineStore('teams', {
 			}
 		},
 
+		/**
+		 * Apply the canonical favorite list to all loaded teams.
+		 *
+		 * @param ids - Ordered favorite identifiers
+		 */
+		applyFavoriteOrder(ids: string[]): void {
+			const positions = new Map(ids.map((id, position) => [id, position]))
+			for (const team of this.teams) {
+				team.isFavorite = positions.has(team.id)
+				team.favoritePosition = positions.get(team.id) ?? null
+			}
+		},
+
+		/**
+		 * Toggle a favorite while preventing overlapping mutations.
+		 *
+		 * @param id - Team identifier
+		 */
+		async toggleFavorite(id: string): Promise<void> {
+			const team = this.getTeam(id)
+			if (!team || this.favoritesUpdating) {
+				return
+			}
+			this.favoritesUpdating = true
+			try {
+				this.applyFavoriteOrder(await api.setTeamFavorite(id, !team.isFavorite))
+			} catch (error) {
+				await this.loadTeams()
+				throw error
+			} finally {
+				this.favoritesUpdating = false
+			}
+		},
+
+		/**
+		 * Persist a favorite order and reconcile server conflicts.
+		 *
+		 * @param ids - Desired favorite order
+		 */
+		async reorderFavoriteTeams(ids: string[]): Promise<void> {
+			if (this.favoritesUpdating) {
+				return
+			}
+			const expected = this.favoriteTeams.map((team) => team.id)
+			this.favoritesUpdating = true
+			try {
+				this.applyFavoriteOrder(await api.reorderFavoriteTeams(ids, expected))
+			} catch (error) {
+				await this.loadTeams()
+				throw error
+			} finally {
+				this.favoritesUpdating = false
+			}
+		},
+
 		/**
 		 * Fetch the full member list (with roles) for a team.
 		 *
diff --git a/src/teams/types.ts b/src/teams/types.ts
index 58c2b54e6..4747b053f 100644
--- a/src/teams/types.ts
+++ b/src/teams/types.ts
@@ -61,6 +61,8 @@ export interface Team {
 	id: string
 	displayName: string
 	description: string
+	isFavorite: boolean
+	favoritePosition: number | null
 	/** Total number of members (may exceed the previewed {@link members}). */
 	memberCount: number
 	/** The current user's role in this team. */
diff --git a/src/teams/views/HomeView.spec.ts b/src/teams/views/HomeView.spec.ts
new file mode 100644
index 000000000..0a2b74385
--- /dev/null
+++ b/src/teams/views/HomeView.spec.ts
@@ -0,0 +1,102 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type * as L10n from '@nextcloud/l10n'
+import type { Team } from '../types.ts'
+
+import { flushPromises, shallowMount } from '@vue/test-utils'
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick, ref } from 'vue'
+import TeamCard from '../components/TeamCard.vue'
+import HomeView from './HomeView.vue'
+import * as api from '../api.ts'
+import { useTeamsStore } from '../store.ts'
+
+vi.mock('../api.ts', () => ({ reorderFavoriteTeams: vi.fn(), setTeamFavorite: vi.fn(), fetchTeams: vi.fn() }))
+vi.mock('../../logger.ts', () => ({ logger: { error: vi.fn() } }))
+vi.mock('@nextcloud/dialogs', () => ({ showError: vi.fn() }))
+vi.mock('@nextcloud/vue/composables/useIsDarkTheme', () => ({ useIsDarkTheme: () => ref(false) }))
+vi.mock('@nextcloud/l10n', async (importOriginal) => ({
+	...await importOriginal<typeof L10n>(),
+	t: (_app: string, text: string) => text,
+}))
+
+function mountHome() {
+	const pinia = createPinia()
+	setActivePinia(pinia)
+	const store = useTeamsStore()
+	store.teams = ['A', 'B'].map((id, position): Team => ({
+		id,
+		displayName: id,
+		description: '',
+		isFavorite: true,
+		favoritePosition: position,
+		memberCount: 0,
+		myRole: 'member',
+		members: [],
+		resources: [],
+	}))
+	const wrapper = shallowMount(HomeView, { global: { plugins: [pinia] } })
+	return { wrapper, store }
+}
+
+function startDrag(wrapper: ReturnType<typeof mountHome>['wrapper']) {
+	const cards = wrapper.findAllComponents(TeamCard)
+	cards[0]!.vm.$emit('dragStart', cards[0]!.props('team'), { dataTransfer: null, preventDefault: vi.fn() })
+	cards[1]!.vm.$emit('dragOver', cards[1]!.props('team'), {
+		preventDefault: vi.fn(),
+		dataTransfer: null,
+	})
+}
+
+describe('favorite ordering in HomeView', () => {
+	beforeEach(() => vi.resetAllMocks())
+
+	it('disables manual sorting while the team list is filtered', async () => {
+		const { wrapper } = mountHome()
+		wrapper.findComponent({ name: 'NcTextField' }).vm.$emit('update:modelValue', 'A')
+		await nextTick()
+
+		const card = wrapper.findComponent(TeamCard)
+		expect(card.props('sortable')).toBe(false)
+		expect(card.props('draggable')).toBe(false)
+		wrapper.unmount()
+	})
+
+	it('discards a cancelled preview without saving or mutating the store', async () => {
+		const { wrapper, store } = mountHome()
+		startDrag(wrapper)
+		await nextTick()
+		expect(wrapper.findAllComponents(TeamCard).map((card) => card.props('team').id)).toEqual(['B', 'A'])
+		expect(store.favoriteTeams.map((team) => team.id)).toEqual(['A', 'B'])
+		wrapper.findAllComponents(TeamCard)[0]!.vm.$emit('dragEnd')
+		await nextTick()
+		expect(wrapper.findAllComponents(TeamCard).map((card) => card.props('team').id)).toEqual(['A', 'B'])
+		expect(api.reorderFavoriteTeams).not.toHaveBeenCalled()
+		wrapper.unmount()
+	})
+
+	it('persists an accepted drop exactly once', async () => {
+		vi.mocked(api.reorderFavoriteTeams).mockResolvedValue(['B', 'A'])
+		const { wrapper, store } = mountHome()
+		startDrag(wrapper)
+		await nextTick()
+		wrapper.findAllComponents(TeamCard)[0]!.element.parentElement!.dispatchEvent(new Event('drop', { bubbles: true, cancelable: true }))
+		wrapper.findAllComponents(TeamCard)[0]!.vm.$emit('dragEnd')
+		await flushPromises()
+		expect(api.reorderFavoriteTeams).toHaveBeenCalledExactlyOnceWith(['B', 'A'], ['A', 'B'])
+		expect(store.favoriteTeams.map((team) => team.id)).toEqual(['B', 'A'])
+		wrapper.unmount()
+	})
+
+	it('ignores external drops without an active team drag', async () => {
+		const { wrapper } = mountHome()
+		wrapper.findAllComponents(TeamCard)[0]!.element.parentElement!.dispatchEvent(new Event('drop', { bubbles: true, cancelable: true }))
+		await flushPromises()
+		expect(api.reorderFavoriteTeams).not.toHaveBeenCalled()
+		wrapper.unmount()
+	})
+})
diff --git a/src/teams/views/HomeView.vue b/src/teams/views/HomeView.vue
index c83dfd210..781516e94 100644
--- a/src/teams/views/HomeView.vue
+++ b/src/teams/views/HomeView.vue
@@ -5,11 +5,12 @@
 
 <script setup lang="ts">
 import { mdiAccountGroupOutline, mdiAlertCircleOutline, mdiMagnify, mdiPlus } from '@mdi/js'
+import { showError } from '@nextcloud/dialogs'
 import { t } from '@nextcloud/l10n'
 import { imagePath } from '@nextcloud/router'
 import { useIsDarkTheme } from '@nextcloud/vue/composables/useIsDarkTheme'
 import { storeToRefs } from 'pinia'
-import { computed, ref } from 'vue'
+import { computed, ref, watch } from 'vue'
 import NcButton from '@nextcloud/vue/components/NcButton'
 import NcEmptyContent from '@nextcloud/vue/components/NcEmptyContent'
 import NcIconSvgWrapper from '@nextcloud/vue/components/NcIconSvgWrapper'
@@ -19,11 +20,158 @@ import TeamCard from '../components/TeamCard.vue'
 import { useTeamsStore } from '../store.ts'
 
 const store = useTeamsStore()
-const { teams, loading, loadError } = storeToRefs(store)
+const { teams, loading, loadError, favoritesUpdating } = storeToRefs(store)
 const { loadTeams, openCreateTeamWizard } = store
 
 const query = ref('')
+const draggedFavoriteId = ref<string | null>(null)
+// Set one frame later so the browser's drag image is captured without the placeholder style.
+const placeholderFavoriteId = ref<string | null>(null)
+let lastSwapTargetId: string | null = null
+const draggedFavoriteOrder = ref<string[] | null>(null)
+const initialDraggedFavoriteOrder = ref<string[] | null>(null)
+// Keeps the dropped order on screen until the server confirms it, so cards don't bounce back.
+const pendingFavoriteOrder = ref<string[] | null>(null)
 const filteredTeams = computed(() => store.searchTeams(query.value))
+const favoriteTeams = computed(() => {
+	const preview = new Map((draggedFavoriteOrder.value ?? pendingFavoriteOrder.value)?.map((id, position) => [id, position]))
+	return filteredTeams.value.filter((team) => team.isFavorite)
+		.toSorted((left, right) => (preview.get(left.id) ?? left.favoritePosition ?? 0) - (preview.get(right.id) ?? right.favoritePosition ?? 0))
+})
+const otherTeams = computed(() => filteredTeams.value.filter((team) => !team.isFavorite))
+
+watch(query, onFavoriteDragEnd)
+watch(() => store.favoriteTeams.map((team) => team.id).join(','), onFavoriteDragEnd)
+
+/**
+ * Toggle a favorite and report failures.
+ *
+ * @param teamId - Team identifier
+ */
+async function toggleFavorite(teamId: string) {
+	try {
+		await store.toggleFavorite(teamId)
+	} catch {
+		showError(t('circles', 'Could not update favorite team'))
+	}
+}
+
+/**
+ * Start a local drag preview without changing the canonical store order.
+ *
+ * @param teamId - Dragged team identifier
+ * @param event - Native drag event
+ */
+function onFavoriteDragStart(teamId: string, event: DragEvent) {
+	if (query.value || favoritesUpdating.value) {
+		event.preventDefault()
+		return
+	}
+	draggedFavoriteId.value = teamId
+	draggedFavoriteOrder.value = store.favoriteTeams.map((team) => team.id)
+	initialDraggedFavoriteOrder.value = [...draggedFavoriteOrder.value]
+	requestAnimationFrame(() => {
+		placeholderFavoriteId.value = draggedFavoriteId.value
+	})
+	if (event.dataTransfer) {
+		event.dataTransfer.effectAllowed = 'move'
+		event.dataTransfer.setData('text/plain', teamId)
+	}
+}
+
+/**
+ * Move a team within the local drag preview.
+ *
+ * @param teamId - Hovered team identifier
+ * @param event - Native drag event
+ */
+function onFavoriteDragOver(teamId: string, event: DragEvent) {
+	const order = draggedFavoriteOrder.value
+	const draggedId = draggedFavoriteId.value
+	if (!order || !draggedId) {
+		return
+	}
+	if (teamId === draggedId) {
+		lastSwapTargetId = null
+		return
+	}
+
+	event.preventDefault()
+	if (event.dataTransfer) {
+		event.dataTransfer.dropEffect = 'move'
+	}
+	// The swapped card animates back under the cursor; don't swap it straight back.
+	if (teamId === lastSwapTargetId) {
+		return
+	}
+	const from = order.indexOf(draggedId)
+	const over = order.indexOf(teamId)
+	if (from === -1 || over === -1) {
+		return
+	}
+	// Take the hovered card's slot; half-based checks break in a multi-column grid.
+	order.splice(from, 1)
+	order.splice(over, 0, draggedId)
+	lastSwapTargetId = teamId
+}
+
+/** Discard a drag preview on cancellation or after a drop. */
+function onFavoriteDragEnd() {
+	draggedFavoriteId.value = null
+	placeholderFavoriteId.value = null
+	lastSwapTargetId = null
+	draggedFavoriteOrder.value = null
+	initialDraggedFavoriteOrder.value = null
+}
+
+/** Persist only a drop accepted by the favorites grid. */
+async function onFavoriteDrop() {
+	const order = draggedFavoriteOrder.value
+	const initialOrder = initialDraggedFavoriteOrder.value
+	onFavoriteDragEnd()
+	if (!order || !initialOrder || order.join('\n') === initialOrder.join('\n')) {
+		return
+	}
+	pendingFavoriteOrder.value = order
+	try {
+		await saveFavoriteOrder(order)
+	} finally {
+		pendingFavoriteOrder.value = null
+	}
+}
+
+/**
+ * Persist an order and announce errors.
+ *
+ * @param order - Desired identifiers
+ */
+async function saveFavoriteOrder(order: string[]) {
+	try {
+		await store.reorderFavoriteTeams(order)
+	} catch {
+		showError(t('circles', 'Could not reorder favorite teams'))
+	}
+}
+
+/**
+ * Swap a favorite with its neighbor and persist the resulting order.
+ *
+ * @param teamId - Team identifier
+ * @param direction - -1 to move up, 1 to move down
+ */
+async function moveFavorite(teamId: string, direction: -1 | 1) {
+	if (favoritesUpdating.value) {
+		return
+	}
+	const order = store.favoriteTeams.map((team) => team.id)
+	const from = order.indexOf(teamId)
+	const to = from + direction
+	if (from === -1 || to < 0 || to >= order.length) {
+		return
+	}
+	[order[from], order[to]] = [order[to], order[from]]
+	await saveFavoriteOrder(order)
+}
 
 const illustrationSrc = imagePath('circles', 'teams-illustration.svg')
 const isDarkTheme = useIsDarkTheme()
@@ -99,9 +247,46 @@ const isDarkTheme = useIsDarkTheme()
 
 			<template v-else>
 				<section :class="$style.homeViewSection">
-					<div v-if="filteredTeams.length > 0" :class="$style.homeViewGrid">
-						<TeamCard v-for="team in filteredTeams" :key="team.id" :team="team" />
-					</div>
+					<template v-if="filteredTeams.length > 0">
+						<h2 v-if="favoriteTeams.length" :class="$style.homeViewSectionTitle">
+							{{ t('circles', 'Favorites') }}
+						</h2>
+						<TransitionGroup
+							v-if="favoriteTeams.length"
+							tag="div"
+							:class="$style.homeViewGrid"
+							:moveClass="$style.homeViewGridMove"
+							@dragover.prevent
+							@drop.prevent="onFavoriteDrop">
+							<TeamCard
+								v-for="(team, index) in favoriteTeams"
+								:key="team.id"
+								:class="{ [$style.homeViewPlaceholder]: team.id === placeholderFavoriteId }"
+								:team="team"
+								:draggable="!query && !favoritesUpdating"
+								:favoriteBusy="favoritesUpdating || !!draggedFavoriteId"
+								:sortable="!query"
+								:canMoveUp="index > 0"
+								:canMoveDown="index < favoriteTeams.length - 1"
+								@toggleFavorite="toggleFavorite(team.id)"
+								@moveUp="moveFavorite(team.id, -1)"
+								@moveDown="moveFavorite(team.id, 1)"
+								@dragStart="(_, event) => onFavoriteDragStart(team.id, event)"
+								@dragOver="(_, event) => onFavoriteDragOver(team.id, event)"
+								@dragEnd="onFavoriteDragEnd" />
+						</TransitionGroup>
+						<h2 v-if="favoriteTeams.length && otherTeams.length" :class="$style.homeViewSectionTitle">
+							{{ t('circles', 'Teams') }}
+						</h2>
+						<div :class="$style.homeViewGrid">
+							<TeamCard
+								v-for="team in otherTeams"
+								:key="team.id"
+								:team="team"
+								:favoriteBusy="favoritesUpdating || !!draggedFavoriteId"
+								@toggleFavorite="toggleFavorite(team.id)" />
+						</div>
+					</template>
 					<NcEmptyContent
 						v-else
 						:name="t('circles', 'No teams found')"
@@ -226,10 +411,30 @@ const isDarkTheme = useIsDarkTheme()
 		gap: calc(3 * var(--default-grid-baseline));
 	}
 
+	&__section-title {
+		margin: 0;
+		font-size: 1.2em;
+	}
+
 	&__grid {
 		display: grid;
 		grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
 		gap: calc(3 * var(--default-grid-baseline));
 	}
+
+	&__grid-move {
+		transition: transform var(--animation-slow) ease;
+
+		@media (prefers-reduced-motion: reduce) {
+			transition: none;
+		}
+	}
+
+	// Marks the slot where the dragged card will land.
+	&__placeholder {
+		opacity: 0.5;
+		outline: 2px dashed var(--color-primary-element);
+		outline-offset: 2px;
+	}
 }
 </style>
diff --git a/tests/unit/lib/Repository/TeamFavoriteRepositoryTest.php b/tests/unit/lib/Repository/TeamFavoriteRepositoryTest.php
new file mode 100644
index 000000000..3a184dac8
--- /dev/null
+++ b/tests/unit/lib/Repository/TeamFavoriteRepositoryTest.php
@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Tests\Repository;
+
+use OCA\Circles\Db\MemberRequest;
+use OCA\Circles\Db\MembershipRequest;
+use OCA\Circles\Model\Member;
+use OCA\Circles\Model\Membership;
+use OCA\Circles\Repository\TeamFavoriteRepository;
+use OCP\IDBConnection;
+use OCP\Server;
+use PHPUnit\Framework\TestCase;
+
+class TeamFavoriteRepositoryTest extends TestCase {
+	private IDBConnection $db;
+	private TeamFavoriteRepository $repository;
+	private string $userId;
+	private string $first;
+	private string $second;
+	private string $third;
+
+	protected function setUp(): void {
+		$this->db = Server::get(IDBConnection::class);
+		$this->repository = Server::get(TeamFavoriteRepository::class);
+		$this->userId = 'favorite-test-' . bin2hex(random_bytes(8));
+		$this->first = bin2hex(random_bytes(7));
+		$this->second = bin2hex(random_bytes(7));
+		$this->third = bin2hex(random_bytes(7));
+		$this->db->beginTransaction();
+	}
+
+	protected function tearDown(): void {
+		$this->db->rollBack();
+	}
+
+	public function testAppendAfterCircleDeletionKeepsOrder(): void {
+		$this->repository->add($this->userId, $this->first);
+		$this->repository->add($this->userId, $this->second);
+		$this->repository->removeCircle($this->first);
+		$this->repository->add($this->userId, $this->third);
+		self::assertSame([$this->second, $this->third], $this->repository->getCircleIds($this->userId));
+	}
+
+	public function testReorderPreservesRowsAndDoesNotDeleteNewFavorites(): void {
+		$this->repository->add($this->userId, $this->first);
+		$this->repository->add($this->userId, $this->second);
+		$before = $this->rows();
+		$this->repository->add($this->userId, $this->third);
+		$this->repository->replaceOrder($this->userId, [$this->second, $this->first]);
+		self::assertSame([$this->second, $this->first, $this->third], $this->repository->getCircleIds($this->userId));
+		$after = $this->rows();
+		foreach ($before as $index => $row) {
+			self::assertSame($row, $after[$index]);
+		}
+	}
+
+	public function testReorderCannotResurrectRemovedFavorites(): void {
+		$this->repository->add($this->userId, $this->first);
+		$this->repository->add($this->userId, $this->second);
+		$this->repository->remove($this->userId, $this->first);
+		$this->repository->replaceOrder($this->userId, [$this->second, $this->first]);
+		self::assertSame([$this->second], $this->repository->getCircleIds($this->userId));
+	}
+
+	public function testReadIncludesDirectAndInheritedMembershipButNotLostAccess(): void {
+		$singleId = bin2hex(random_bytes(7));
+		$groupId = bin2hex(random_bytes(7));
+		$memberRequest = Server::get(MemberRequest::class);
+		$memberRequest->save($this->member($this->first, $singleId, $this->userId, Member::TYPE_USER));
+		$memberRequest->save($this->member($this->second, $groupId, 'favorite-test-group', Member::TYPE_GROUP));
+		$membership = new Membership();
+		$membership->setCircleId($this->second);
+		$membership->setSingleId($singleId);
+		$membership->setLevel(Member::LEVEL_MEMBER);
+		$membership->setInheritanceFirst($groupId);
+		$membership->setInheritanceLast($groupId);
+		$membership->setInheritancePath([$groupId]);
+		$membership->setInheritanceDepth(1);
+		$memberships = Server::get(MembershipRequest::class);
+		$memberships->insert($membership);
+		foreach ([$this->first, $this->second, $this->third] as $circleId) {
+			$this->repository->add($this->userId, $circleId);
+		}
+		self::assertSame([$this->first, $this->second], $this->repository->getCircleIds($this->userId, true));
+		$memberships->delete($membership);
+		self::assertSame([$this->first], $this->repository->getCircleIds($this->userId, true));
+	}
+
+	public function testUserCleanupDoesNotAffectOtherUsers(): void {
+		$this->repository->add($this->userId, $this->first);
+		$this->repository->add($this->userId . '-other', $this->first);
+		$this->repository->removeUser($this->userId);
+		self::assertSame([], $this->repository->getCircleIds($this->userId));
+		self::assertSame([$this->first], $this->repository->getCircleIds($this->userId . '-other'));
+	}
+
+	private function member(string $circleId, string $singleId, string $userId, int $type): Member {
+		$member = new Member();
+		$member->setCircleId($circleId);
+		$member->setSingleId($singleId);
+		$member->setId(bin2hex(random_bytes(7)));
+		$member->setUserId($userId);
+		$member->setUserType($type);
+		$member->setLevel(Member::LEVEL_MEMBER);
+		$member->setStatus(Member::STATUS_MEMBER);
+		return $member;
+	}
+
+	/**
+	 * @return list<array<string, mixed>>
+	 */
+	private function rows(): array {
+		$query = $this->db->getQueryBuilder();
+		$query->select('id', 'circle_id', 'created')->from('circles_team_favorites')
+			->where($query->expr()->eq('user_id', $query->createNamedParameter($this->userId)))
+			->orderBy('id');
+		$result = $query->executeQuery();
+		$rows = $result->fetchAll();
+		$result->closeCursor();
+		return $rows;
+	}
+}
diff --git a/tests/unit/lib/Service/TeamFavoriteServiceTest.php b/tests/unit/lib/Service/TeamFavoriteServiceTest.php
new file mode 100644
index 000000000..c87927e87
--- /dev/null
+++ b/tests/unit/lib/Service/TeamFavoriteServiceTest.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Circles\Tests\Unit\Service;
+
+use OCA\Circles\Repository\TeamFavoriteRepository;
+use OCA\Circles\Service\PermissionService;
+use OCA\Circles\Service\TeamFavoriteService;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\IUser;
+use OCP\IUserSession;
+use OCP\Lock\ILockingProvider;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class TeamFavoriteServiceTest extends TestCase {
+	private TeamFavoriteRepository&MockObject $request;
+	private PermissionService&MockObject $permissions;
+	private ILockingProvider&MockObject $locks;
+	private TeamFavoriteService $service;
+
+	protected function setUp(): void {
+		$this->request = $this->createMock(TeamFavoriteRepository::class);
+		$this->permissions = $this->createMock(PermissionService::class);
+		$this->locks = $this->createMock(ILockingProvider::class);
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')->willReturn('alice');
+		$session = $this->createMock(IUserSession::class);
+		$session->method('getUser')->willReturn($user);
+		$this->service = new TeamFavoriteService($this->request, $this->permissions, $session, $this->locks);
+	}
+
+	public function testReadOnlyReturnsAccessibleFavorites(): void {
+		$this->request->expects(self::once())->method('getCircleIds')->with('alice', true)->willReturn(['B']);
+		$this->request->expects(self::never())->method('remove');
+		self::assertSame(['B'], $this->service->getFavoriteCircleIds());
+	}
+
+	public function testReorderPrunesFormerMembershipAndReturnsCanonicalOrder(): void {
+		$this->request->method('getCircleIds')->willReturnOnConsecutiveCalls(['gone', 'A', 'B'], ['A', 'B'], ['B', 'A']);
+		$this->request->expects(self::once())->method('remove')->with('alice', 'gone');
+		$this->request->expects(self::once())->method('replaceOrder')->with('alice', ['B', 'A']);
+		$this->permissions->expects(self::never())->method('userMustBeMember');
+		$this->expectLockReleased();
+		self::assertSame(['B', 'A'], $this->service->reorder(['B', 'A'], ['A', 'B']));
+	}
+
+	public function testStaleOrderIsRejectedWithoutOverwritingAnotherTab(): void {
+		$this->request->method('getCircleIds')->willReturn(['A', 'B', 'C']);
+		$this->request->expects(self::never())->method('replaceOrder');
+		$this->expectLockReleased();
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(409);
+		$this->service->reorder(['B', 'A'], ['A', 'B']);
+	}
+
+	public function testChangedOrderWithSameFavoritesIsRejected(): void {
+		$this->request->method('getCircleIds')->willReturn(['B', 'A']);
+		$this->request->expects(self::never())->method('replaceOrder');
+		$this->expectLockReleased();
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(409);
+		$this->service->reorder(['B', 'A'], ['A', 'B']);
+	}
+
+	public function testDuplicateIdsAreRejectedBeforeAccessingDatabase(): void {
+		$this->request->expects(self::never())->method('getCircleIds');
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(400);
+		$this->service->reorder(['A', 'A'], ['A', 'B']);
+	}
+
+	public function testUnchangedOrderDoesNotWrite(): void {
+		$this->request->method('getCircleIds')->willReturn(['A']);
+		$this->request->expects(self::never())->method('replaceOrder');
+		$this->expectLockReleased();
+		self::assertSame(['A'], $this->service->reorder(['A'], ['A']));
+	}
+
+	public function testAlreadyFavoriteIsIdempotent(): void {
+		$this->request->method('getCircleIds')->willReturn(['A']);
+		$this->request->expects(self::never())->method('add');
+		$this->expectLockReleased();
+		self::assertSame(['A'], $this->service->setFavorite('A', true));
+	}
+
+	public function testLockIsReleasedOnDatabaseFailure(): void {
+		$this->request->method('getCircleIds')->willReturn(['A', 'B']);
+		$this->request->method('replaceOrder')->willThrowException(new \RuntimeException('database unavailable'));
+		$this->expectLockReleased();
+		$this->expectException(\RuntimeException::class);
+		$this->service->reorder(['B', 'A'], ['A', 'B']);
+	}
+
+	private function expectLockReleased(): void {
+		$lock = 'circles:team-favorites:' . hash('sha256', 'alice');
+		$this->locks->expects(self::once())->method('acquireLock')->with($lock, ILockingProvider::LOCK_EXCLUSIVE);
+		$this->locks->expects(self::once())->method('releaseLock')->with($lock, ILockingProvider::LOCK_EXCLUSIVE);
+	}
+}