diff --git a/services/identity/src/config.rs b/services/identity/src/config.rs
index 8abb3000f..cf972a058 100644
--- a/services/identity/src/config.rs
+++ b/services/identity/src/config.rs
@@ -1,164 +1,162 @@
 use base64::{engine::general_purpose, DecodeError, Engine as _};
 use clap::{Parser, Subcommand};
 use once_cell::sync::Lazy;
 use std::{collections::HashSet, env, fmt, fs, io, path};
 use tracing::{error, info};
 
 use crate::constants::{
   DEFAULT_TUNNELBROKER_ENDPOINT, KEYSERVER_PUBLIC_KEY, LOCALSTACK_ENDPOINT,
   OPAQUE_SERVER_SETUP, SECRETS_DIRECTORY, SECRETS_SETUP_FILE,
   TUNNELBROKER_GRPC_ENDPOINT,
 };
 
 /// Raw CLI arguments, should be only used internally to create ServerConfig
 static CLI: Lazy<Cli> = Lazy::new(Cli::parse);
 
 pub static CONFIG: Lazy<ServerConfig> = Lazy::new(|| {
   ServerConfig::from_cli(&CLI).expect("Failed to load server config")
 });
 
 pub(super) fn parse_cli_command() -> &'static Command {
   &Lazy::force(&CLI).command
 }
 
 pub(super) fn load_server_config() -> &'static ServerConfig {
   Lazy::force(&CONFIG)
 }
 
 #[derive(Parser)]
 #[clap(author, version, about, long_about = None)]
 #[clap(propagate_version = true)]
 struct Cli {
   #[clap(subcommand)]
   command: Command,
 
   /// AWS Localstack service URL
   #[arg(long, global = true)]
   #[arg(env = LOCALSTACK_ENDPOINT)]
   localstack_endpoint: Option<String>,
 
   /// Tunnelbroker gRPC endpoint
   #[arg(long, global = true)]
   #[arg(env = TUNNELBROKER_GRPC_ENDPOINT)]
   #[arg(default_value = DEFAULT_TUNNELBROKER_ENDPOINT)]
   tunnelbroker_endpoint: String,
 }
 
 #[derive(Subcommand)]
 pub enum Command {
   /// Runs the server
   Server,
   /// Generates and persists a keypair to use for PAKE registration and login
   Keygen {
     #[arg(short, long)]
     #[arg(default_value = SECRETS_DIRECTORY)]
     dir: String,
   },
-  /// Populates the `identity-users` table in DynamoDB from MySQL
-  PopulateDB,
 }
 
 #[derive(Clone)]
 pub struct ServerConfig {
   pub localstack_endpoint: Option<String>,
   // Opaque 2.0 server secrets
   pub server_setup: comm_opaque2::ServerSetup<comm_opaque2::Cipher>,
   // Reserved usernames
   pub reserved_usernames: HashSet<String>,
   pub keyserver_public_key: Option<String>,
   pub tunnelbroker_endpoint: String,
 }
 
 impl ServerConfig {
   fn from_cli(cli: &Cli) -> Result<Self, Error> {
     if !matches!(cli.command, Command::Server) {
       panic!("ServerConfig is only available for the `server` command");
     }
 
     info!("Tunnelbroker endpoint: {}", &cli.tunnelbroker_endpoint);
     if let Some(endpoint) = &cli.localstack_endpoint {
       info!("Using Localstack endpoint: {}", endpoint);
     }
 
     let mut path_buf = path::PathBuf::new();
     path_buf.push(SECRETS_DIRECTORY);
     path_buf.push(SECRETS_SETUP_FILE);
 
     let server_setup = get_server_setup(path_buf.as_path())?;
     let reserved_usernames = get_reserved_usernames_set()?;
     let keyserver_public_key = env::var(KEYSERVER_PUBLIC_KEY).ok();
 
     Ok(Self {
       localstack_endpoint: cli.localstack_endpoint.clone(),
       tunnelbroker_endpoint: cli.tunnelbroker_endpoint.clone(),
       server_setup,
       reserved_usernames,
       keyserver_public_key,
     })
   }
 
   pub fn is_dev(&self) -> bool {
     self.localstack_endpoint.is_some()
   }
 }
 
 impl fmt::Debug for ServerConfig {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     f.debug_struct("ServerConfig")
       .field("server_keypair", &"** redacted **")
       .field("keyserver_auth_token", &"** redacted **")
       .field("localstack_endpoint", &self.localstack_endpoint)
       .finish()
   }
 }
 
 #[derive(Debug, derive_more::Display, derive_more::From)]
 pub enum Error {
   #[display(...)]
   Opaque(comm_opaque2::ProtocolError),
   #[display(...)]
   Io(io::Error),
   #[display(...)]
   Env(env::VarError),
   #[display(...)]
   Json(serde_json::Error),
   #[display(...)]
   Decode(DecodeError),
 }
 
 fn get_server_setup(
   path: &path::Path,
 ) -> Result<comm_opaque2::ServerSetup<comm_opaque2::Cipher>, Error> {
   let encoded_server_setup = if let Ok(env_setup) =
     env::var(OPAQUE_SERVER_SETUP)
   {
     info!(
       "Using OPAQUE server setup from env var: {}",
       OPAQUE_SERVER_SETUP
     );
     env_setup
   } else if let Ok(file_setup) = fs::read_to_string(path) {
     info!("Using OPAQUE server setup from file: {}", path.display());
     file_setup
   } else {
     error!("Unable to locate OPAQUE server setup. Please run `keygen` command and run Identity service again.");
     return Err(Error::Io(io::Error::new(
       io::ErrorKind::NotFound,
       "Missing server credentials",
     )));
   };
 
   let decoded_server_setup =
     general_purpose::STANDARD_NO_PAD.decode(encoded_server_setup)?;
   comm_opaque2::ServerSetup::deserialize(&decoded_server_setup)
     .map_err(Error::Opaque)
 }
 
 fn get_reserved_usernames_set() -> Result<HashSet<String>, Error> {
   // All entries in `reserved_usernames.json` must be lowercase and must also be
   // included in `lib/utils/reserved-users.js`!!
   let contents = include_str!("../reserved_usernames.json");
   let reserved_usernames: Vec<String> = serde_json::from_str(contents)?;
 
   Ok(reserved_usernames.into_iter().collect())
 }
diff --git a/services/identity/src/main.rs b/services/identity/src/main.rs
index c047f1754..f42420016 100644
--- a/services/identity/src/main.rs
+++ b/services/identity/src/main.rs
@@ -1,86 +1,85 @@
 use std::time::Duration;
 
 use config::Command;
 use database::DatabaseClient;
 use moka::future::Cache;
 use tonic::transport::Server;
 use tonic_web::GrpcWebLayer;
 
 mod client_service;
 mod config;
 pub mod constants;
 mod cors;
 mod database;
 pub mod ddb_utils;
 pub mod error;
 mod grpc_services;
 mod grpc_utils;
 mod id;
 mod keygen;
 mod nonce;
 mod reserved_users;
 mod siwe;
 mod token;
 mod tunnelbroker;
 
 use constants::IDENTITY_SERVICE_SOCKET_ADDR;
 use cors::cors_layer;
 use keygen::generate_and_persist_keypair;
 use tracing::{self, info, Level};
 use tracing_subscriber::EnvFilter;
 
 use client_service::{ClientService, IdentityClientServiceServer};
 use grpc_services::authenticated::AuthenticatedService;
 use grpc_services::protos::auth::identity_client_service_server::IdentityClientServiceServer as AuthServer;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
   let filter = EnvFilter::builder()
     .with_default_directive(Level::INFO.into())
     .with_env_var(EnvFilter::DEFAULT_ENV)
     .from_env_lossy();
 
   let subscriber = tracing_subscriber::fmt().with_env_filter(filter).finish();
 
   tracing::subscriber::set_global_default(subscriber)?;
   match config::parse_cli_command() {
     Command::Keygen { dir } => {
       generate_and_persist_keypair(dir)?;
     }
     Command::Server => {
       config::load_server_config();
       let addr = IDENTITY_SERVICE_SOCKET_ADDR.parse()?;
       let aws_config = aws_config::from_env().region("us-east-2").load().await;
       let database_client = DatabaseClient::new(&aws_config);
       let workflow_cache = Cache::builder()
         .time_to_live(Duration::from_secs(10))
         .build();
       let inner_client_service =
         ClientService::new(database_client.clone(), workflow_cache.clone());
       let client_service = IdentityClientServiceServer::with_interceptor(
         inner_client_service,
         grpc_services::shared::version_interceptor,
       );
       let inner_auth_service =
         AuthenticatedService::new(database_client.clone(), workflow_cache);
       let auth_service =
         AuthServer::with_interceptor(inner_auth_service, move |req| {
           grpc_services::authenticated::auth_interceptor(req, &database_client)
             .and_then(grpc_services::shared::version_interceptor)
         });
 
       info!("Listening to gRPC traffic on {}", addr);
       Server::builder()
         .accept_http1(true)
         .layer(cors_layer())
         .layer(GrpcWebLayer::new())
         .add_service(client_service)
         .add_service(auth_service)
         .serve(addr)
         .await?;
     }
-    Command::PopulateDB => unimplemented!(),
   }
 
   Ok(())
 }