Python / Uvicorn Fundamentals Interview Questions

# Minimal install - pure Python, good for restricted environments
pip install uvicorn

# Standard install - Cython-based performance extras
pip install "uvicorn[standard]"

# Pin a specific version for reproducible deployments
pip install "uvicorn[standard]==0.30.1"

# Verify installation
uvicorn --version

# Install in a virtual environment (recommended)
python -m venv .venv
source .venv/bin/activate   # Linux/macOS
.venv\Scripts\activate       # Windows
pip install "uvicorn[standard]"

# File: main.py
async def app(scope, receive, send):
    assert scope['type'] == 'http'
    await send({
        'type': 'http.response.start',
        'status': 200,
        'headers': [(b'content-type', b'text/plain')],
    })
    await send({
        'type': 'http.response.body',
        'body': b'Hello, world!',
    })

# Run from the terminal:
# uvicorn main:app

# Basic run - listens on 127.0.0.1:8000
uvicorn main:app

# Custom host and port
uvicorn main:app --host 0.0.0.0 --port 8080

# Development mode with auto-reload
uvicorn main:app --reload

# FastAPI example
# File: api.py
from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

# Run FastAPI app
uvicorn api:app --reload

# Nested attribute path
# File: mypackage/server.py with app = FastAPI()
uvicorn mypackage.server:app

# To make the server externally accessible (development/testing):
uvicorn main:app --host 0.0.0.0

# Production: always specify host explicitly
uvicorn main:app --host 0.0.0.0 --port 8000

# Check what's running:
curl http://127.0.0.1:8000/

# The WEB_CONCURRENCY environment variable sets default worker count
export WEB_CONCURRENCY=4
uvicorn main:app  # will start 4 workers

# Uvicorn automatically uses uvloop when installed
# Install via standard extras:
pip install "uvicorn[standard]"

# Or force uvloop explicitly:
uvicorn main:app --loop uvloop

# Force asyncio (e.g. for debugging or PyPy):
uvicorn main:app --loop asyncio

# Check which event loop is active (in your app):
import asyncio
print(type(asyncio.get_event_loop()))  # will show uvloop.Loop when active

# Programmatic config:
uvicorn.run("main:app", loop="uvloop")

# Auto - picks httptools if available (recommended for production)
uvicorn main:app --http auto

# Force httptools (fast, production)
uvicorn main:app --http httptools

# Force h11 (pure Python, debugging, PyPy)
uvicorn main:app --http h11

# h11 also has a configurable buffer limit:
# --limit-max-requests sets max request buffer size (h11 only)
uvicorn main:app --http h11 --limit-max-requests 1000

# Basic auto-reload (restarts when any .py file changes)
uvicorn main:app --reload

# Watch specific directories instead of the entire working directory
uvicorn main:app --reload --reload-dir src/
uvicorn main:app --reload --reload-dir src/ --reload-dir tests/

# Include extra file patterns to watch
uvicorn main:app --reload --reload-include "*.html" --reload-include "*.css"

# Exclude patterns from watching
uvicorn main:app --reload --reload-exclude "*.log"

# IMPORTANT: --reload and --workers are mutually exclusive!
# This will raise an error:
# uvicorn main:app --reload --workers 4  ← WRONG

import uvicorn

# Method 1: uvicorn.run() - simplest programmatic start
if __name__ == "__main__":
    uvicorn.run(
        "main:app",          # string import path
        host="0.0.0.0",
        port=8000,
        reload=True,         # development only
        log_level="info",
    )

# You can also pass the app object directly (no reload support):
# uvicorn.run(app, host="0.0.0.0", port=8000)

# Method 2: uvicorn.Config + uvicorn.Server - more control
import uvicorn

if __name__ == "__main__":
    config = uvicorn.Config("main:app", port=5000, log_level="info")
    server = uvicorn.Server(config)
    server.run()

# Method 3: Running inside an existing async loop
import asyncio
import uvicorn

async def main():
    config = uvicorn.Config("main:app", port=5000, log_level="info")
    server = uvicorn.Server(config)
    await server.serve()  # use serve() not run() inside async context

if __name__ == "__main__":
    asyncio.run(main())

# Run 4 worker processes
uvicorn main:app --workers 4

# Workers can also be set via environment variable:
export WEB_CONCURRENCY=4
uvicorn main:app

# Common formula for worker count:
# workers = (2 x CPU cores) + 1  for I/O-bound apps
# workers = CPU cores             for CPU-bound apps
import multiprocessing
workers = (2 * multiprocessing.cpu_count()) + 1

# IMPORTANT: --workers and --reload are mutually exclusive

# Install the uvicorn-worker package (the uvicorn.workers module is deprecated)
pip install uvicorn-worker

# Run with Gunicorn + UvicornWorker
gunicorn main:app -w 4 -k uvicorn_worker.UvicornWorker

# Full production command:
gunicorn main:app \
    --workers 4 \
    --worker-class uvicorn_worker.UvicornWorker \
    --bind 0.0.0.0:8000 \
    --timeout 120 \
    --keep-alive 5 \
    --access-logfile - \
    --error-logfile -

# PyPy-compatible configuration:
gunicorn main:app -w 4 -k uvicorn_worker.UvicornH11Worker

# Using a gunicorn.conf.py file
# gunicorn --config gunicorn.conf.py main:app

# gunicorn.conf.py
import multiprocessing

bind = "0.0.0.0:8000"
workers = (2 * multiprocessing.cpu_count()) + 1
worker_class = "uvicorn_worker.UvicornWorker"
worker_connections = 1000
max_requests = 10000
max_requests_jitter = 1000
timeout = 120
graceful_timeout = 30
keepalive = 5

# Run with SSL (requires certificate and private key)
uvicorn main:app \
    --ssl-keyfile ./key.pem \
    --ssl-certfile ./cert.pem \
    --host 0.0.0.0 \
    --port 443

# With a CA bundle (for mutual TLS / client certificates)
uvicorn main:app \
    --ssl-keyfile ./key.pem \
    --ssl-certfile ./cert.pem \
    --ssl-ca-certs ./ca-bundle.pem

# Programmatic SSL config
import ssl
import uvicorn

if __name__ == "__main__":
    uvicorn.run(
        "main:app",
        ssl_keyfile="./key.pem",
        ssl_certfile="./cert.pem",
        host="0.0.0.0",
        port=443,
    )

# Local development HTTPS with mkcert:
# 1. Install mkcert: brew install mkcert
# 2. mkcert -install
# 3. mkcert localhost 127.0.0.1
# 4. uvicorn main:app --ssl-keyfile localhost-key.pem --ssl-certfile localhost.pem

# FastAPI lifespan example (modern approach)
from contextlib import asynccontextmanager
from fastapi import FastAPI

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: runs before the server begins accepting requests
    print("Starting up...")
    app.state.db = await connect_to_database()
    yield  # server is running here
    # Shutdown: runs after the server stops accepting requests
    print("Shutting down...")
    await app.state.db.close()

app = FastAPI(lifespan=lifespan)

# Pure ASGI lifespan implementation
async def app(scope, receive, send):
    if scope["type"] == "lifespan":
        while True:
            message = await receive()
            if message["type"] == "lifespan.startup":
                # do startup work
                await send({"type": "lifespan.startup.complete"})
            elif message["type"] == "lifespan.shutdown":
                # do cleanup
                await send({"type": "lifespan.shutdown.complete"})
                return
    # ... HTTP handling

# Log level options: critical, error, warning, info (default), debug, trace
uvicorn main:app --log-level debug

# Disable access log (reduces CPU by ~10% under high load)
uvicorn main:app --no-access-log

# Disable colour in logs (useful for log aggregators)
uvicorn main:app --no-use-colors

# Use a custom logging config file (JSON, YAML, or INI)
uvicorn main:app --log-config logging.yaml

# Programmatic log config:
uvicorn.run("main:app", log_level="warning", access_log=False)

# Production hardened logging:
uvicorn main:app \
    --log-level warning \
    --no-access-log \
    --no-use-colors

# logging.yaml - custom Uvicorn log config
version: 1
formatters:
  default:
    format: "%(asctime)s %(levelname)s %(message)s"
    use_colors: false
  access:
    format: '%(asctime)s %(client_addr)s - "%(request_line)s" %(status_code)s'
handlers:
  default:
    class: logging.StreamHandler
    formatter: default
  access:
    class: logging.StreamHandler
    formatter: access
loggers:
  uvicorn:
    handlers: [default]
    level: INFO
  uvicorn.access:
    handlers: [access]
    level: INFO
    propagate: false

# Enable proxy headers (enabled by default, trusts only 127.0.0.1)
uvicorn main:app --proxy-headers

# Trust a specific proxy IP
uvicorn main:app --proxy-headers --forwarded-allow-ips 10.0.0.1

# Trust multiple proxy IPs or a subnet
uvicorn main:app \
    --proxy-headers \
    --forwarded-allow-ips "10.0.0.0/8,172.16.0.0/12"

# Trust ALL proxies (use ONLY on trusted internal networks!)
uvicorn main:app --proxy-headers --forwarded-allow-ips "*"

# Disable proxy headers (if no reverse proxy in front)
uvicorn main:app --no-proxy-headers

# Set via environment variable:
export FORWARDED_ALLOW_IPS="10.0.0.1,10.0.0.2"
uvicorn main:app --proxy-headers

# Pure ASGI WebSocket application
async def app(scope, receive, send):
    if scope["type"] == "websocket":
        # Accept the WebSocket connection
        await send({"type": "websocket.accept"})
        while True:
            event = await receive()
            if event["type"] == "websocket.receive":
                data = event.get("text") or event.get("bytes")
                # Echo the message back
                await send({"type": "websocket.send", "text": data})
            elif event["type"] == "websocket.disconnect":
                break

# FastAPI WebSocket example
from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Echo: {data}")

# Without root-path: app thinks it lives at /
# Nginx config: location /api/v1/ { proxy_pass http://127.0.0.1:8000; }
uvicorn main:app  # scope["root_path"] == ""

# With root-path: app knows it is mounted at /api/v1
uvicorn main:app --root-path /api/v1
# scope["root_path"] == "/api/v1"

# FastAPI uses root_path for generating correct OpenAPI docs URLs
# Without it, /docs links will be wrong when behind a proxy
from fastapi import FastAPI
app = FastAPI(root_path="/api/v1")  # set in the app OR in Uvicorn CLI

# Programmatic:
uvicorn.run("main:app", root_path="/api/v1")

# Bind to a Unix domain socket
uvicorn main:app --uds /tmp/uvicorn.sock

# Programmatic:
uvicorn.run("main:app", uds="/tmp/uvicorn.sock")

# Nginx config to proxy to the Unix socket:
# upstream app {
#     server unix:/tmp/uvicorn.sock;
# }
# server {
#     location / {
#         proxy_pass http://app;
#     }
# }

# Bind to a file descriptor (for socket activation, e.g. systemd):
uvicorn main:app --fd 3
# systemd passes the pre-bound socket as fd 3

# Without --factory: APP is the application object directly
uvicorn main:app

# With --factory: create_app() is called to produce the ASGI app
uvicorn main:create_app --factory

# Example factory function:
# main.py
def create_app():
    from fastapi import FastAPI
    app = FastAPI()

    @app.get("/")
    def root():
        return {"status": "ok"}

    return app

# The factory is called with no arguments and must return the ASGI app

# Programmatic equivalent:
uvicorn.run("main:create_app", factory=True, port=8000)

# Why use a factory?
# - Deferred initialisation (resources created only when workers start)
# - Different config per environment (testing vs production)
# - Integration with dependency injection frameworks
# - Worker-level initialisation (each Gunicorn worker calls the factory separately)

# Environment variable equivalents of CLI flags
export UVICORN_HOST=0.0.0.0
export UVICORN_PORT=8000
export UVICORN_WORKERS=4
export UVICORN_LOG_LEVEL=warning
export UVICORN_LOOP=uvloop
export UVICORN_HTTP=httptools
export UVICORN_RELOAD=false
export UVICORN_NO_ACCESS_LOG=true
export UVICORN_PROXY_HEADERS=true
export UVICORN_FORWARDED_ALLOW_IPS="10.0.0.1"

# Then run with minimal flags:
uvicorn main:app

# Partial override: env vars + CLI flags (CLI takes precedence)
export UVICORN_PORT=8000
uvicorn main:app --port 9000  # uses 9000 (CLI overrides env var)

# WEB_CONCURRENCY is also respected for workers:
export WEB_CONCURRENCY=4
uvicorn main:app

# NOTE: UVICORN_* env vars cannot be set inside --env-file
# --env-file is for configuring your APPLICATION, not Uvicorn itself

# Auto-detect (default - recommended)
uvicorn main:app --interface auto

# Explicit ASGI3 (FastAPI, Starlette, modern frameworks)
uvicorn main:app --interface asgi3

# WSGI mode (for Django without channels, Flask)
uvicorn main:app --interface wsgi
# WARNING: WSGI mode disables WebSocket support entirely

# Programmatic:
uvicorn.run("main:app", interface="asgi3")

# Dockerfile - single-container Uvicorn
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Expose the port
EXPOSE 8000

# Run Uvicorn - bind 0.0.0.0 so Docker can forward traffic
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000",
     "--workers", "4", "--loop", "uvloop", "--http", "httptools",
     "--log-level", "info", "--no-access-log"]

# requirements.txt:
# uvicorn[standard]
# fastapi

# docker-compose.yml
services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - UVICORN_HOST=0.0.0.0
      - UVICORN_PORT=8000
      - UVICORN_WORKERS=4
      - UVICORN_LOG_LEVEL=info
      - WEB_CONCURRENCY=4
    command: uvicorn main:app

# Health check - uvicorn has no built-in health endpoint
# Add one to your application:
# @app.get("/health")
# def health(): return {"status": "ok"}

# Uvicorn responds to these OS signals:
# SIGINT  (Ctrl+C)       - graceful shutdown
# SIGTERM (kill default) - graceful shutdown (Kubernetes uses this)
# SIGQUIT                - graceful shutdown with core dump
# SIGKILL (kill -9)      - immediate termination (not catchable)

# Kubernetes sends SIGTERM before SIGKILL:
# Pod termination sequence:
# 1. SIGTERM sent to container
# 2. Uvicorn begins graceful shutdown
# 3. Completes in-flight requests
# 4. SIGKILL sent after terminationGracePeriodSeconds (default 30s)

# Programmatic graceful shutdown:
import asyncio
import signal
import uvicorn

async def main():
    config = uvicorn.Config("main:app", port=8000)
    server = uvicorn.Server(config)

    loop = asyncio.get_running_loop()
    loop.add_signal_handler(
        signal.SIGTERM,
        lambda: asyncio.create_task(server.shutdown())
    )

    await server.serve()

asyncio.run(main())

# Production-hardened Uvicorn command
uvicorn main:app \
    --host 0.0.0.0 \
    --port 8000 \
    --workers 4 \
    --loop uvloop \
    --http httptools \
    --log-level warning \
    --no-access-log \
    --no-server-header \
    --no-date-header \
    --proxy-headers \
    --forwarded-allow-ips "10.0.0.0/8"

# Or using environment variables (recommended for containers):
export UVICORN_HOST=0.0.0.0
export UVICORN_PORT=8000
export UVICORN_WORKERS=4
export UVICORN_LOOP=uvloop
export UVICORN_HTTP=httptools
export UVICORN_LOG_LEVEL=warning
export UVICORN_NO_ACCESS_LOG=true
export UVICORN_NO_SERVER_HEADER=true
export UVICORN_PROXY_HEADERS=true
export UVICORN_FORWARDED_ALLOW_IPS="10.0.0.0/8"
uvicorn main:app

# /etc/systemd/system/myapp.service
[Unit]
Description=My FastAPI Application
After=network.target

[Service]
Type=simple
User=www-data
Group=www-data
WorkingDirectory=/var/www/myapp
Environment="PATH=/var/www/myapp/.venv/bin"
EnvironmentFile=/var/www/myapp/.env
ExecStart=/var/www/myapp/.venv/bin/uvicorn main:app \
    --host 127.0.0.1 \
    --port 8000 \
    --workers 4 \
    --loop uvloop \
    --log-level warning
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

# Enable and start the service
sudo systemctl daemon-reload
sudo systemctl enable myapp
sudo systemctl start myapp

# Check status and logs
sudo systemctl status myapp
journalctl -u myapp -f      # follow live logs
journalctl -u myapp --since "1 hour ago"

# Reload after config change
sudo systemctl restart myapp

# Graceful restart (sends SIGTERM then restarts)
sudo systemctl reload-or-restart myapp

# Socket activation (advanced - systemd creates the socket)
# myapp.socket + myapp.service - Uvicorn started only when first connection arrives
uvicorn main:app --fd 0  # fd 0 passed by systemd socket activation

# main.py - FastAPI application
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

# Uvicorn runs the FastAPI app:
# uvicorn main:app --reload

# FastAPI is itself an ASGI-compliant application:
# It implements: async def __call__(self, scope, receive, send)
# Uvicorn calls this callable for every incoming request

# Development:
# uvicorn main:app --reload --host 127.0.0.1 --port 8000

# Production:
# gunicorn main:app -w 4 -k uvicorn_worker.UvicornWorker

# Configure keep-alive timeout (how long idle connections stay open)
uvicorn main:app --timeout-keep-alive 10

# Graceful shutdown timeout (force-kill after N seconds if requests don't finish)
uvicorn main:app --timeout-graceful-shutdown 30

# Worker health check timeout
uvicorn main:app --timeout-worker-healthcheck 10

# Programmatic:
uvicorn.run(
    "main:app",
    timeout_keep_alive=10,
    timeout_graceful_shutdown=30,
)

# Gunicorn has its own timeout settings that overlay Uvicorn's:
# gunicorn --timeout 120  (worker timeout for handling a request)
# gunicorn --graceful-timeout 30  (graceful shutdown window)

# main.py - minimal HTTP ASGI app
async def app(scope, receive, send):
    assert scope["type"] == "http"

    # Read the request body
    body = b""
    more_body = True
    while more_body:
        message = await receive()
        body += message.get("body", b"")
        more_body = message.get("more_body", False)

    # Send the HTTP response
    response_body = b"Hello, world!"
    await send({
        "type": "http.response.start",
        "status": 200,
        "headers": [
            (b"content-type", b"text/plain"),
            (b"content-length", str(len(response_body)).encode()),
        ],
    })
    await send({
        "type": "http.response.body",
        "body": response_body,
    })

# Run: uvicorn main:app

# Streaming response - send body in multiple chunks
async def streaming_app(scope, receive, send):
    assert scope["type"] == "http"
    await send({
        "type": "http.response.start",
        "status": 200,
        "headers": [(b"content-type", b"text/plain")],
    })
    for chunk in [b"Hello", b", ", b"world!"]:
        await send({
            "type": "http.response.body",
            "body": chunk,
            "more_body": True,  # indicates more chunks are coming
        })
    await send({"type": "http.response.body", "body": b"", "more_body": False})

# logging.json - custom log config in dictConfig format
{
  "version": 1,
  "disable_existing_loggers": false,
  "formatters": {
    "default": {
      "()": "uvicorn.logging.DefaultFormatter",
      "fmt": "%(levelprefix)s %(asctime)s %(message)s",
      "use_colors": false
    },
    "access": {
      "()": "uvicorn.logging.AccessFormatter",
      "fmt": '%(levelprefix)s %(asctime)s %(client_addr)s - "%(request_line)s" %(status_code)s',
      "use_colors": false
    }
  },
  "handlers": {
    "default": {
      "formatter": "default",
      "class": "logging.StreamHandler",
      "stream": "ext://sys.stderr"
    },
    "access": {
      "formatter": "access",
      "class": "logging.StreamHandler",
      "stream": "ext://sys.stdout"
    }
  },
  "loggers": {
    "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": false},
    "uvicorn.error": {"level": "INFO"},
    "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false}
  }
}

# Use the custom log config:
uvicorn main:app --log-config logging.json

# Or YAML format (requires PyYAML - included in uvicorn[standard]):
uvicorn main:app --log-config logging.yaml

# Programmatically:
import logging.config, json
with open("logging.json") as f:
    log_config = json.load(f)
uvicorn.run("main:app", log_config=log_config)

# Project structure:
# /project/
#   src/
#     myapp/
#       main.py    ← app lives here

# Without --app-dir: run from /project/src/
cd /project/src
uvicorn myapp.main:app

# With --app-dir: run from /project/
cd /project
uvicorn myapp.main:app --app-dir src
# Equivalent to: PYTHONPATH=/project/src uvicorn myapp.main:app

# Docker example - app in /app/src
CMD ["uvicorn", "myapp.main:app", "--app-dir", "src",
     "--host", "0.0.0.0", "--port", "8000"]

# Programmatic:
uvicorn.run("myapp.main:app", app_dir="src")

# Multiple app directories: use PYTHONPATH env var instead
export PYTHONPATH=/project/src:/project/lib
uvicorn myapp.main:app

# Using httpx.AsyncClient with ASGITransport (pure async test)
import pytest
import httpx
from main import app

@pytest.mark.anyio
async def test_homepage():
    async with httpx.AsyncClient(
        transport=httpx.ASGITransport(app=app),
        base_url="http://test"
    ) as client:
        response = await client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

# Using Starlette / FastAPI TestClient (sync interface, uses anyio)
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

# Testing lifespan events with TestClient
def test_with_lifespan():
    with TestClient(app) as client:
        # lifespan startup has run at this point
        response = client.get("/")
        assert response.status_code == 200
    # lifespan shutdown has run after the with block

# Install Granian
pip install granian

# Run the same FastAPI/Starlette/ASGI app:
granian --interface asgi main:app

# With HTTP/2 + TLS:
granian --interface asgi main:app \
    --host 0.0.0.0 \
    --port 443 \
    --ssl-certificate cert.pem \
    --ssl-keyfile key.pem \
    --http2

# Workers:
granian --interface asgi main:app --workers 4

# Inspecting the scope in an ASGI app
async def app(scope, receive, send):
    print(scope["type"])      # "http", "websocket", or "lifespan"

    if scope["type"] == "http":
        print(scope["method"])          # "GET", "POST", etc.
        print(scope["path"])            # "/api/users"
        print(scope["query_string"])    # b"page=1&limit=10"
        print(scope["headers"])         # list of (name, value) byte tuples
        print(scope["client"])          # ("127.0.0.1", 54321) - IP and port
        print(scope["server"])          # ("127.0.0.1", 8000)
        print(scope["scheme"])          # "http" or "https"
        print(scope["root_path"])       # e.g. "/api/v1" if --root-path is set
        print(scope["http_version"])    # "1.1"

    elif scope["type"] == "websocket":
        print(scope["path"])            # WebSocket path
        print(scope["headers"])         # Upgrade headers
        print(scope["subprotocols"])    # Requested sub-protocols

    elif scope["type"] == "lifespan":
        pass  # handle startup and shutdown events

# Kubernetes Deployment snippet
spec:
  containers:
    - name: api
      image: myapp:latest
      command: ["uvicorn", "main:app",
               "--host", "0.0.0.0",
               "--port", "8000",
               "--workers", "2",
               "--timeout-graceful-shutdown", "25"]
      ports:
        - containerPort: 8000
      env:
        - name: UVICORN_LOG_LEVEL
          value: "warning"
      livenessProbe:
        httpGet:
          path: /health
          port: 8000
        initialDelaySeconds: 5
        periodSeconds: 10
      readinessProbe:
        httpGet:
          path: /ready
          port: 8000
        initialDelaySeconds: 2
        periodSeconds: 5
      lifecycle:
        preStop:
          exec:
            command: ["sleep", "5"]  # allow load balancer to de-register