Interface Segregation, Critically

Four implementations must gain a method, two of which exist only for tests and one of which belongs to another team. Eleven consumers recompile. The other team's build breaks on a change they were not told about, which converts an hour of work into a cross-team incident.

The method lands on the contract that has one consumer. Test doubles for reading and writing are unaffected because they do not implement the bulk contract. The other team compiles against UserReader and never sees the change.

interface UserFinder     { findById(id): User | null }
interface UserSearcher   { search(q): User[] }
interface UserCreator    { create(u): void }
interface UserUpdater    { update(u): void }
interface UserDeleter    { delete(id): void }
// ...nine more, one method each

class ProfilePage {
  constructor(
    private finder: UserFinder,
    private updater: UserUpdater,
    private searcher: UserSearcher,
    private deleter: UserDeleter,   // needed for "close account"
  ) {}
}
// Four parameters where there was one, and none of the
// four names describes anything a stakeholder talks about.

interface UserReader {              // the read-only consumers
  findById(id): User | null
  search(q): User[]
}

interface UserWriter {              // the profile and admin flows
  create(u): void
  update(u): void
  delete(id): void
}

interface BulkUserOps { /* import, anonymise */ }
interface ComplianceExporter { /* gdpr export */ }

class ProfilePage {
  constructor(private users: UserReader, private edit: UserWriter) {}
}
// One implementation satisfies all four.
// The reporting service takes only UserReader — and therefore
// cannot delete a user, which review no longer has to check.