How To Use Multiple Identities Online Compartmentalization

Identity compartmentalization—the practice of separating your online activities into distinct, isolated contexts—reduces your attack surface and protects your privacy. When you use a single identity across all websites, a data breach or tracking profile potentially exposes your entire digital life. This guide covers practical strategies for developers and power users to implement effective identity separation.

Understanding Identity Compartmentalization

The core principle is simple: different contexts should not know about each other. Your work email should not be linked to your personal social media. Your development environment should not share cookies with your banking sessions. Each identity operates in its own silo, limiting cross-referencing and reducing exposure if one identity is compromised.

For developers, compartmentalization also means isolating test environments, development tooling, and production credentials. The techniques below apply to both personal privacy and professional security.

Browser-Level Isolation

The browser is your primary interface with the web, making it the most critical isolation point.

Firefox Multi-Account Containers

Firefox’s Multi-Account Containers extension creates persistent isolated contexts. Each container maintains its own cookies, localStorage, and site data.

# Install containers CLI for automation (requires Firefox)
npm install -g @mozilla/containerize

# Create a container for work identity
containerize create work

# Launch a URL in a specific container
containerize open --container=work https://mail.google.com

You can assign websites to containers automatically using the container bookmarks extension or write custom rules:

// Container rules example (container-assignments.json)
{
  "rules": [
    { "domain": "github.com", "container": "work" },
    { "domain": "twitter.com", "container": "personal" },
    { "domain": "stackoverflow.com", "container": "dev" }
  ]
}

Browser Profile Isolation

For stronger isolation, use separate browser profiles. Chrome and Firefox both support multiple profiles:

# Chrome: launch with specific profile
google-chrome --profile-directory="Profile_work"
google-chrome --profile-directory="Profile_personal"

# Firefox: create and use profiles
firefox -P  # Opens profile manager
firefox -P "WorkProfile" https://github.com
firefox -P "PersonalProfile" https://twitter.com

Create a simple shell script to launch the right profile:

#!/bin/bash
# launch-browser.sh

PROFILE="$1"
URL="$2"

case "$PROFILE" in
  work)
    google-chrome --profile-directory="Profile_work" "$URL"
    ;;
  personal)
    google-chrome --profile-directory="Profile_personal" "$URL"
    ;;
  banking)
    google-chrome --profile-directory="Profile_banking" "$URL"
    ;;
  *)
    echo "Usage: $0 {work|personal|banking} <url>"
    ;;
esac

Email Aliasing Strategies

Email is the foundation of online identity. Using aliases separates your contact information across contexts.

Plus Addressing

Most email providers support plus addressing—appending +tag to your address:

yourname@gmail.com → yourname+shopping@gmail.com
yourname@gmail.com → yourname+dev@gmail.com

This lets you filter emails and identify which service leaked your address.

Catch-All Aliases

If you own a domain, configure catch-all routing:

*@yourdomain.com → delivers to your inbox

Create unique aliases for each service:

github@yourdomain.com → development-related accounts
netflix@yourdomain.com → entertainment services

Password Manager Integration

1Password and Bitwarden support generating unique email aliases through built-in integrations:

# 1Password CLI: generate masked email
op item get "github" --field=email
# Returns: myname+github@privaterelay.apple.com

This routes emails through the provider’s relay service, hiding your real address.

Container-Based Network Isolation

Beyond browser isolation, consider network-level separation.

Hosts File Management

Maintain separate hosts configurations for different identities:

# /etc/hosts.work
127.0.0.1 analytics.tracker.com
127.0.0.1 ad-server.example.com

# Activate with: sudo hosts-work && dscacheutil -flushcache

Use a tool like Hosts to manage multiple hosts files:

# Install hosts CLI
brew install hosts

# Switch between host configurations
hosts use work
hosts use personal

VPN-Based Separation

Route different identities through different VPN endpoints:

# Split tunnel based on application
# Using WireGuard config example

[Peer]
PublicKey = <work-vpn-key>
AllowedIPs = 10.0.0.0/8  # Corporate network only

[Peer]
PublicKey = <personal-vpn-key>
AllowedIPs = 0.0.0.0/0, ::/0  # Everything else

For simpler use cases, use browser-specific VPN extensions or separate VPN connections on different network interfaces.

Code Development Isolation

Developers need to separate development, testing, and production contexts.

Environment Variable Segregation

Usedirenv or similar tools to load context-specific variables:

# .envrc for project directory
export AWS_PROFILE=personal-dev
export DATABASE_URL=postgres://localhost/devdb
export API_KEY=dev-key-xxx

Create separate credential sets for each context and activate them based on directory:

# ~/projects/personal/.envrc
export AWS_PROFILE=personal
export NPM_TOKEN=personal-npm-token

# ~/projects/work/.envrc
export AWS_PROFILE=work
export NPM_TOKEN=work-npm-token

Git Configuration Per-Repository

Set git identity per repository to avoid accidental commits with the wrong identity:

# Inside work repository
git config user.name "Your Name"
git config user.email "you@company.com"

# Inside personal repository
git config user.name "Your Name"
git config user.email "personal@email.com"

Or use includeIf in your global gitconfig:

# ~/.gitconfig
[includeIf "gitdir:~/projects/work/"]
    path = ~/.gitconfig-work

[includeIf "gitdir:~/projects/personal/"]
    path = ~/.gitconfig-personal

Implementation Workflow

Start implementing compartmentalization incrementally:

Audit your current identities: List all online accounts and categorize them
Choose your isolation method: Browser profiles for simplicity, containers for flexibility, VMs for maximum isolation
Create initial boundaries: Start with work vs. personal separation
Add email aliases: Set up catch-all routing for new services
Automate: Write scripts to launch the correct context
Iterate: Add more compartments as needed

When to Escalate Isolation

Basic compartmentalization works for most users. Consider stronger measures when:

Working with sensitive data or clients requiring confidentiality
Handling cryptocurrency or financial accounts
Testing untrusted software
Operating in high-threat environments

Options include dedicated physical machines, virtualization with QubesOS, or air-gapped systems for the most sensitive work.

Effective identity compartmentalization reduces your attack surface and limits data correlation. Start with browser profiles and email aliases, then add network-level isolation as needed. The effort scales with your threat model—most users benefit from basic separation, while high-risk users need more rigorous boundaries.

Built by theluckystrike — More at zovo.one