diff --git a/.github/workflows/deploy.yaml b/.github/workflows/deploy.yaml
index f1ff81ba..bd35b30e 100644
--- a/.github/workflows/deploy.yaml
+++ b/.github/workflows/deploy.yaml
@@ -18,11 +18,24 @@ jobs:
       - name: Login to Amazon ECR
         id: login-ecr
         uses: aws-actions/amazon-ecr-login@v1
-      - name: Build and push images
+      - name: Build and push handler
         uses: docker/build-push-action@v4
         with:
           context: .
           push: true
-          tags: ${{ steps.login-ecr.outputs.registry }}/wca-registration:latest
+          file: dockerfile.handler
+          tags: ${{ steps.login-ecr.outputs.registry }}/wca-registration-handler:latest
           cache-from: type=gha
           cache-to: type=gha,mode=max
+      - name: Build and push worker
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          file: dockerfile.worker
+          tags: ${{ steps.login-ecr.outputs.registry }}/wca-registration-worker:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+      - name: Deploy worker
+        run: |
+          aws ecs update-service --cluster wca-registration --service wca-registration-worker --force-new-deployment
diff --git a/.gitignore b/.gitignore
index 1a6a12ce..c5925fce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,5 +35,5 @@
 .idea
 tmp
 node_modules
-storage
+localstack
 yarn.lock
diff --git a/Gemfile b/Gemfile
index 19b3bf80..eef68c22 100644
--- a/Gemfile
+++ b/Gemfile
@@ -3,6 +3,7 @@ git_source(:github) { |repo| "https://github.com/thewca/wca-registration.git" }
 
 ruby "3.2.2"
 
+# Gems that are only needed by the handler not the worker
 # Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
 gem "rails", "~> 7.0.4", ">= 7.0.4.3"
 
@@ -15,6 +16,12 @@ gem "puma", "~> 5.0"
 # Build JSON APIs with ease [https://github.com/rails/jbuilder]
 gem "jbuilder"
 
+# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
+gem "rack-cors"
+
+# Reduces boot times through caching; required in config/boot.rb
+gem "bootsnap", require: false
+
 # Use Redis adapter to run Action Cable in production
 gem "redis", "~> 4.0"
 gem 'hiredis'
@@ -22,23 +29,15 @@ gem 'hiredis'
 # DynamoDB for storing registrations
 gem 'aws-sdk-dynamodb'
 
+# SQS for adding data into a queue
+gem 'aws-sdk-sqs'
+
 # Use Kredis to get higher-level data types in Redis [https://github.com/rails/kredis]
 gem "kredis"
 
-# Use Active Model has_secure_password [https://guides.rubyonrails.org/active_model_basics.html#securepassword]
-# gem "bcrypt", "~> 3.1.7"
-
 # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
 gem "tzinfo-data", platforms: %i[ mingw mswin x64_mingw jruby ]
 
-# Reduces boot times through caching; required in config/boot.rb
-gem "bootsnap", require: false
-
-# Use Active Storage variants [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
-# gem "image_processing", "~> 1.2"
-
-# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
-gem "rack-cors"
 
 group :development, :test do
   # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
diff --git a/Gemfile.lock b/Gemfile.lock
index 24ac9848..151ce33e 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -76,6 +76,9 @@ GEM
     aws-sdk-dynamodb (1.84.0)
       aws-sdk-core (~> 3, >= 3.165.0)
       aws-sigv4 (~> 1.1)
+    aws-sdk-sqs (1.55.0)
+      aws-sdk-core (~> 3, >= 3.165.0)
+      aws-sigv4 (~> 1.1)
     aws-sigv4 (1.5.2)
       aws-eventstream (~> 1, >= 1.0.2)
     bootsnap (1.16.0)
@@ -181,6 +184,7 @@ PLATFORMS
 
 DEPENDENCIES
   aws-sdk-dynamodb
+  aws-sdk-sqs
   bootsnap
   debug
   hiredis
diff --git a/app/controllers/metrics_controller.rb b/app/controllers/metrics_controller.rb
new file mode 100644
index 00000000..7a0c4c3e
--- /dev/null
+++ b/app/controllers/metrics_controller.rb
@@ -0,0 +1,16 @@
+require 'securerandom'
+class MetricsController < ApplicationController
+  def index
+    # Get the queue attributes
+    queue_url = $sqs.get_queue_url(queue_name: "registrations.fifo").queue_url
+    response = $sqs.get_queue_attributes({
+                queue_url: queue_url,
+                attribute_names: ["ApproximateNumberOfMessages"]
+              })
+
+    # Get the queue size
+    queue_size = response.attributes["ApproximateNumberOfMessages"].to_i
+
+    render json: { queue_size: queue_size}
+  end
+end
diff --git a/app/controllers/registration_controller.rb b/app/controllers/registration_controller.rb
index ff0d3bc0..314ebce6 100644
--- a/app/controllers/registration_controller.rb
+++ b/app/controllers/registration_controller.rb
@@ -5,27 +5,95 @@ def create
     competition_id = params[:competition_id]
     event_ids = params[:event_ids]
 
-    unless user_can_register(competitor_id, competition_id)
+    unless validate_request(competitor_id, competition_id)
       return render json: { status: 'User cannot register, wrong format' }, status: :forbidden
     end
 
-    registration = {
-      id: SecureRandom.uuid,
+    id = SecureRandom.uuid
+
+    step_data = {
       competitor_id: competitor_id,
       competition_id: competition_id,
-      registration_data: {
-        event_ids: event_ids
-      }
+      event_ids: event_ids,
+      registration_status: "waiting",
+      step: "Event Registration"
     }
+    queue = Aws::SQS::Queue.new($sqs.get_queue_url(queue_name: "registrations.fifo").queue_url)
 
-    $dynamodb.put_item({
-       table_name: 'Registrations',
-       item: registration
-    })
+    queue.send_message({
+     queue_url: $queue,
+     message_body: step_data.to_json,
+     message_group_id: id,
+     message_deduplication_id: id
+     })
+
+    render json: { status: 'ok', message: "Started Registration Process" }
+  end
+
+  def update
+    competitor_id = params[:competitor_id]
+    competition_id = params[:competition_id]
+    status = params[:status]
+
+    unless validate_request(competitor_id, competition_id, status)
+      return render json: { status: 'User cannot register, wrong format' }, status: :forbidden
+    end
+
+    # Specify the key attributes for the item to be updated
+    key = {
+      'competitor_id' => competitor_id,
+      'competition_id' => competition_id
+    }
+
+    # Set the expression for the update operation
+    update_expression = 'set registration_status = :s'
+    expression_attribute_values = {
+      ':s' => status
+    }
 
-    render json: { status: 'ok' }
+    begin
+      # Update the item in the table
+      $dynamodb.update_item({
+         table_name: "Registrations",
+         key: key,
+         update_expression: update_expression,
+         expression_attribute_values: expression_attribute_values
+       })
+      return render json: { status: 'ok' }
+    rescue Aws::DynamoDB::Errors::ServiceError => e
+      return render json: { status: 'Failed to update registration data' }, status: :internal_server_error
+    end
   end
 
+  def delete
+    competitor_id = params[:competitor_id]
+    competition_id = params[:competition_id]
+
+    unless validate_request(competitor_id, competition_id)
+      return render json: { status: 'User cannot register, wrong format' }, status: :forbidden
+    end
+
+    # Define the key of the item to delete
+    key = {
+      "competition_id" => competition_id,
+      "competitor_id" => competitor_id
+    }
+
+    begin
+      # Call the delete_item method to delete the item from the table
+      $dynamodb.delete_item(
+        table_name: "Registrations",
+        key: key
+      )
+
+      # Render a success response
+      return render json: { status: 'ok' }
+
+    rescue Aws::DynamoDB::Errors::ServiceError => error
+      # Render an error response
+      return render json: { status: "Error deleting item from DynamoDB: #{error.message}" }, status: :internal_server_error
+    end
+  end
   def list
     competition_id = params[:competition_id]
     registrations = get_registrations(competition_id)
@@ -35,11 +103,13 @@ def list
 
   private
 
-  def user_can_register(competitor_id, competition_id)
+  REGISTRATION_STATUS = %w[waiting accepted]
+
+  def validate_request(competitor_id, competition_id, status="waiting")
     # check that competitor ID is in the correct format
     if competitor_id =~ /^\d{4}[a-zA-Z]{4}\d{2}$/
       # check that competition ID is in the correct format
-      if competition_id =~ /^[a-zA-Z]+\d{4}$/
+      if competition_id =~ /^[a-zA-Z]+\d{4}$/ and REGISTRATION_STATUS.include? status
         return true
       end
     end
diff --git a/app/worker/queue_poller.rb b/app/worker/queue_poller.rb
new file mode 100644
index 00000000..94d47ce1
--- /dev/null
+++ b/app/worker/queue_poller.rb
@@ -0,0 +1,37 @@
+require 'json'
+require 'aws-sdk-sqs'
+require_relative 'registration_processor'
+
+class QueuePoller
+  # Wait for 1 second so we can start work on 10 messages at at time
+  # These numbers can be tweaked after load testing
+  WAIT_TIME = 1
+  MAX_MESSAGES = 10
+
+  def self.perform
+    if ENV['LOCALSTACK_ENDPOINT']
+      @sqs ||= Aws::SQS::Client.new(endpoint: ENV['LOCALSTACK_ENDPOINT'])
+    else
+      @sqs ||= Aws::SQS::Client.new
+    end
+
+    queue = @sqs.get_queue_url(queue_name: "registrations.fifo").queue_url
+    poller = Aws::SQS::QueuePoller.new(queue)
+    poller.poll(wait_time_seconds: WAIT_TIME, max_number_of_messages: MAX_MESSAGES) do |messages|
+      messages.each do |msg|
+        # Messages are deleted from the queue when the block returns normally!
+        puts "Received message with ID: #{msg.message_id}"
+        puts "Message body: #{msg.body}"
+        body = JSON.parse msg.body
+        begin
+          RegistrationProcessor.process_message(body)
+        rescue StandardError => e
+          # unexpected error occurred while processing messages,
+          # log it, and skip delete so it can be re-processed later
+          puts "Error #{e} when processing message with ID #{msg}"
+          throw :skip_delete
+        end
+      end
+    end
+  end
+end
diff --git a/app/worker/registration_processor.rb b/app/worker/registration_processor.rb
new file mode 100644
index 00000000..3211b926
--- /dev/null
+++ b/app/worker/registration_processor.rb
@@ -0,0 +1,31 @@
+require 'aws-sdk-dynamodb'
+
+class RegistrationProcessor
+  def self.process_message(message)
+    if ENV['LOCALSTACK_ENDPOINT']
+      @dynamodb ||= Aws::DynamoDB::Client.new(endpoint: ENV['LOCALSTACK_ENDPOINT'])
+    else
+      @dynamodb ||= Aws::DynamoDB::Client.new
+    end
+    # implement your message processing logic here
+    puts "Working on Message: #{message}"
+    if message['step'] == "Event Registration"
+      registration = {
+        competitor_id: message['competitor_id'],
+        competition_id: message['competition_id'],
+        event_ids: message['event_ids'],
+        registration_status: "waiting",
+      }
+      save_registration(registration)
+    end
+  end
+
+  private
+
+  def self.save_registration(registration)
+    @dynamodb.put_item({
+       table_name: 'Registrations',
+       item: registration
+     })
+  end
+end
diff --git a/config/application.rb b/config/application.rb
index 3e001aa0..f87e984f 100644
--- a/config/application.rb
+++ b/config/application.rb
@@ -11,14 +11,6 @@ class Application < Rails::Application
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 7.0
 
-    # Configuration for the application, engines, and railties goes here.
-    #
-    # These settings can be overridden in specific environments using the files
-    # in config/environments, which are processed later.
-    #
-    # config.time_zone = "Central Time (US & Canada)"
-    # config.eager_load_paths << Rails.root.join("extras")
-
     # Only loads a smaller set of middleware suitable for API only apps.
     # Middleware like session, flash, cookies can be added back manually.
     # Skip views, helpers and assets when generating a new resource.
diff --git a/config/initializers/aws.rb b/config/initializers/aws.rb
index 9c5b64db..f554f378 100644
--- a/config/initializers/aws.rb
+++ b/config/initializers/aws.rb
@@ -1,14 +1,11 @@
 # config/initializers/aws.rb
 
 if Rails.env.production?
-  # We are using IAM Roles to authenticate in prod
-  Aws.config.update({
-    region: ENV["AWS_REGION"],
-  })
   $dynamodb = Aws::DynamoDB::Client.new
+  $sqs = Aws::SQS::Client.new
+  $queue = ENV["QUEUE_URL"]
 else
-  # We are using fake values in dev
-  $dynamodb = Aws::DynamoDB::Client.new(endpoint: ENV['DYNAMODB_ENDPOINT'], region: "my-cool-region-1", credentials: Aws::Credentials.new('my_cool_key', 'my_cool_secret'))
+  # We are using localstack to emulate AWS in dev
+  $dynamodb = Aws::DynamoDB::Client.new(endpoint: ENV['LOCALSTACK_ENDPOINT'])
+  $sqs = Aws::SQS::Client.new(endpoint: ENV['LOCALSTACK_ENDPOINT'])
 end
-
-
diff --git a/config/puma.rb b/config/puma.rb
index daaf0369..f1661d44 100644
--- a/config/puma.rb
+++ b/config/puma.rb
@@ -24,18 +24,18 @@
 # Specifies the `pidfile` that Puma will use.
 pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
 
-# Specifies the number of `workers` to boot in clustered mode.
-# Workers are forked web server processes. If using threads and workers together
-# the concurrency of the application would be max `threads` * `workers`.
+# Specifies the number of `worker` to boot in clustered mode.
+# Workers are forked web server processes. If using threads and worker together
+# the concurrency of the application would be max `threads` * `worker`.
 # Workers do not work on JRuby or Windows (both of which do not support
 # processes).
 #
-# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+# worker ENV.fetch("WEB_CONCURRENCY") { 2 }
 
-# Use the `preload_app!` method when specifying a `workers` number.
+# Use the `preload_app!` method when specifying a `worker` number.
 # This directive tells Puma to first boot the application and load code
 # before forking the application. This takes advantage of Copy On Write
-# process behavior so workers use less memory.
+# process behavior so worker use less memory.
 #
 # preload_app!
 
diff --git a/config/routes.rb b/config/routes.rb
index 6ff93207..c1b6b632 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -1,5 +1,8 @@
 Rails.application.routes.draw do
   get '/healthcheck', to: 'healthcheck#index'
   post '/register', to: 'registration#create'
+  patch '/register', to: 'registration#update'
+  delete '/register', to: 'registration#delete'
   get '/registrations', to: 'registration#list'
+  get '/metrics', to: 'metrics#index'
 end
diff --git a/db/seeds.rb b/db/seeds.rb
index 572eae75..683a970a 100644
--- a/db/seeds.rb
+++ b/db/seeds.rb
@@ -1,3 +1,4 @@
+# Create the DynamoDB Tables
 table_name = 'Registrations'
 key_schema = [
   { attribute_name: 'competition_id', key_type: 'HASH' },
@@ -17,3 +18,12 @@
  attribute_definitions: attribute_definitions,
  provisioned_throughput: provisioned_throughput
 })
+
+# Create SQS Queue
+queue_name = 'registrations.fifo'
+$sqs.create_queue({
+                    queue_name: queue_name,
+                    attributes: {
+                      "FifoQueue": "true"
+                    }
+                  })
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 4c88c5c7..b152a110 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,16 +1,19 @@
 version: "3.8"
 services:
-  wca_registration:
+  wca_registration_handler:
     build:
       context: .
       dockerfile: dockerfile.dev
     ports:
       - "3001:3000"
     environment:
-      DYNAMODB_ENDPOINT: "http://dynamodb-local:8000"
+      LOCALSTACK_ENDPOINT: "http://localstack:4566"
+      AWS_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: "fake-key"
+      AWS_SECRET_ACCESS_KEY: "fake-access-key"
     volumes:
       - .:/app
-      - gems_volume:/usr/local/bundle
+      - gems_volume_handler:/usr/local/bundle
     tty: true
     # First, install Ruby and Node dependencies
     # Start the server and bind to 0.0.0.0 (vs 127.0.0.1) so Docker's port mappings work correctly
@@ -20,13 +23,47 @@ services:
     networks:
       - wca-registration
     depends_on:
-      - dynamodb-local
+      - localstack
 
-  dynamodb-local:
-    image: amazon/dynamodb-local:latest
-    container_name: dynamodb-local
+  wca_registration_worker:
+    build:
+      context: .
+      dockerfile: dockerfile.dev
+    environment:
+      LOCALSTACK_ENDPOINT: "http://localstack:4566"
+      AWS_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: "fake-key"
+      AWS_SECRET_ACCESS_KEY: "fake-access-key"
+
+    volumes:
+      - .:/app
+      - gems_volume_worker:/usr/local/bundle
+    tty: true
+    # First, install Ruby and Node dependencies
+    # Start the server and bind to 0.0.0.0 (vs 127.0.0.1) so Docker's port mappings work correctly
+    command: >
+      bash -c 'bundle install &&
+      while ! curl http://wca_registration_handler:3000/healthcheck >/dev/null 2>&1; do
+              echo "Waiting for Handler to be ready" && sleep 5 ;
+            done && ruby -r "/app/app/worker/queue_poller.rb" -e "QueuePoller.perform"'
+    networks:
+      - wca-registration
+    depends_on:
+      - wca_registration_handler
+
+  # Emulate AWS Services Locally
+  localstack:
+    container_name: "localstack"
+    image: localstack/localstack
     ports:
-      - "8000:8000"
+      - "127.0.0.1:4566:4566"            # LocalStack Gateway
+      - "127.0.0.1:4510-4559:4510-4559"  # external services port range
+    environment:
+      - DEBUG=${DEBUG-}
+      - DOCKER_HOST=unix:///var/run/docker.sock
+    volumes:
+      - "./localstack/volume:/var/lib/localstack"
+      - "/var/run/docker.sock:/var/run/docker.sock"
     networks:
       - wca-registration
 
@@ -35,16 +72,21 @@ services:
     ports:
       - "8001:8001"
     environment:
-      DYNAMO_ENDPOINT: "http://dynamodb-local:8000"
-      AWS_REGION: "us-west-2"
-      AWS_ACCESS_KEY_ID: local
-      AWS_SECRET_ACCESS_KEY: local
+      DYNAMO_ENDPOINT: "http://localstack:4566"
+      AWS_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: my_cool_key
+      AWS_SECRET_ACCESS_KEY: my_cool_secret
     depends_on:
-      - dynamodb-local
+      - localstack
+    networks:
+      - wca-registration
 
 volumes:
-  gems_volume:
+  gems_volume_handler:
     driver: local
+  gems_volume_worker:
+    driver: local
+
 
 networks:
   wca-registration:
diff --git a/docker-compose.test.yml b/docker-compose.test.yml
index 59da857a..21516101 100644
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@@ -1,25 +1,74 @@
 version: "3.8"
 services:
-  wca_registration:
+  wca_registration_handler:
     build:
       context: .
       dockerfile: dockerfile.dev
     ports:
       - "3001:3000"
     environment:
-      WCA_MAIN: test
+      LOCALSTACK_ENDPOINT: "http://localstack:4566"
+      AWS_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: "fake-key"
+      AWS_SECRET_ACCESS_KEY: "fake-access-key"
     volumes:
       - .:/app
-      - gems_volume:/usr/local/bundle
+      - gems_volume_handler:/usr/local/bundle
     tty: true
     command: >
       bash -c 'bundle install && yarn install &&
       bin/rails test'
     networks:
       - wca-registration
+    depends_on:
+      - localstack
+
+  wca_registration_worker:
+    build:
+      context: .
+      dockerfile: dockerfile.dev
+    environment:
+      LOCALSTACK_ENDPOINT: "http://localstack:4566"
+      AWS_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: "fake-key"
+      AWS_SECRET_ACCESS_KEY: "fake-access-key"
+
+    volumes:
+      - .:/app
+      - gems_volume_worker:/usr/local/bundle
+    tty: true
+    # First, install Ruby and Node dependencies
+    # Start the server and bind to 0.0.0.0 (vs 127.0.0.1) so Docker's port mappings work correctly
+    command: >
+      bash -c 'bundle install &&
+      while ! curl http://wca_registration_handler:3000/healthcheck >/dev/null 2>&1; do
+              echo "Waiting for Handler to be ready" && sleep 5 ;
+            done && ruby -r "/app/app/worker/queue_poller.rb" -e "QueuePoller.perform"'
+    networks:
+      - wca-registration
+    depends_on:
+      - wca_registration_handler
+
+  # Emulate AWS Services Locally
+  localstack:
+    container_name: "localstack"
+    image: localstack/localstack
+    ports:
+      - "127.0.0.1:4566:4566"            # LocalStack Gateway
+      - "127.0.0.1:4510-4559:4510-4559"  # external services port range
+    environment:
+      - DEBUG=${DEBUG-}
+      - DOCKER_HOST=unix:///var/run/docker.sock
+    volumes:
+      - "./localstack/volume:/var/lib/localstack"
+      - "/var/run/docker.sock:/var/run/docker.sock"
+    networks:
+      - wca-registration
 
 volumes:
-  gems_volume:
+  gems_volume_handler:
+    driver: local
+  gems_volume_worker:
     driver: local
 
 networks:
diff --git a/dockerfile b/dockerfile.handler
similarity index 100%
rename from dockerfile
rename to dockerfile.handler
diff --git a/dockerfile.worker b/dockerfile.worker
new file mode 100644
index 00000000..7997f4cc
--- /dev/null
+++ b/dockerfile.worker
@@ -0,0 +1,31 @@
+FROM ruby:3.2.2
+EXPOSE 3000
+
+ENV DEBIAN_FRONTEND noninteractive
+WORKDIR /app
+
+# Add PPA needed to install nodejs.
+# From: https://github.com/nodesource/distributions
+RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
+
+# Add PPA needed to install yarn.
+# From: https://yarnpkg.com/en/docs/install#debian-stable
+RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
+RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" > /etc/apt/sources.list.d/yarn.list
+
+RUN apt-get update && apt-get install -y \
+  yarn \
+  build-essential \
+  nodejs \
+  libssl-dev \
+  libyaml-dev \
+  tzdata
+
+RUN gem update --system && gem install bundler
+COPY . .
+
+ENV RAILS_ENV production
+
+RUN bundle install --without development test # Install production gems for the worker
+
+CMD ["ruby", "-r", "/app/app/worker/queue_poller.rb", "-e" , "QueuePoller.perform"]
diff --git a/infra/app.tf b/infra/app.tf
deleted file mode 100644
index 92f83cd7..00000000
--- a/infra/app.tf
+++ /dev/null
@@ -1,433 +0,0 @@
-resource "aws_security_group" "cluster" {
-  name        = "${var.name_prefix}-cluster"
-  description = "Production ECS cluster"
-  vpc_id      = aws_vpc.this.id
-
-  tags = {
-    Name = "${var.name_prefix}-cluster"
-  }
-}
-
-# Note: we use the standalone SG rules (rather than inline), because
-# cluster_cluster_ingress references the SG itself
-
-resource "aws_security_group_rule" "cluster_lb_ingress" {
-  type                     = "ingress"
-  security_group_id        = aws_security_group.cluster.id
-  from_port                = 0
-  to_port                  = 0
-  protocol                 = "-1"
-  source_security_group_id = aws_security_group.lb.id
-  description              = "Load balancer ingress"
-}
-
-resource "aws_security_group_rule" "cluster_cluster_ingress" {
-  type                     = "ingress"
-  security_group_id        = aws_security_group.cluster.id
-  from_port                = 0
-  to_port                  = 0
-  protocol                 = "-1"
-  source_security_group_id = aws_security_group.cluster.id
-  description              = "Allow ingress from other members of the cluster"
-}
-
-resource "aws_security_group_rule" "cluster_all_egress" {
-  type              = "egress"
-  security_group_id = aws_security_group.cluster.id
-  from_port         = 0
-  to_port           = 0
-  protocol          = "-1"
-  cidr_blocks       = ["0.0.0.0/0"]
-  description       = "Allow all egress"
-}
-
-
-resource "aws_cloudwatch_log_group" "this" {
-  name = var.name_prefix
-}
-
-resource "aws_ecs_cluster" "this" {
-  name = var.name_prefix
-}
-
-locals {
-  app_environment = [
-    {
-      name  = "HOST"
-      value = var.host
-    },
-    {
-      name  = "WCA_HOST"
-      value = var.wca_host
-    },
-    {
-      name = "AWS_REGION"
-      value = var.region
-    }
-  ]
-}
-
-#resource "aws_ecs_task_definition" "migrate" {
-#  family = "${var.name_prefix}-migrate"
-#
-#  network_mode             = "awsvpc"
-#  requires_compatibilities = ["EC2"]
-#
-#  cpu    = 512
-#  memory = 512
-#
-#  container_definitions = jsonencode([
-#    {
-#      name         = "main"
-#      image        = "${aws_ecr_repository.this.repository_url}:latest"
-#      command      = ["/app/bin/migrate"]
-#      portMappings = []
-#      logConfiguration = {
-#        logDriver = "awslogs"
-#        options = {
-#          awslogs-group         = "${aws_cloudwatch_log_group.this.name}"
-#          awslogs-region        = "${var.region}"
-#          awslogs-stream-prefix = "${var.name_prefix}"
-#        }
-#      }
-#      environment = local.app_environment
-#    }
-#  ])
-#
-#  tags = {
-#    Name = "${var.name_prefix}-migrate"
-#  }
-#}
-
-data "aws_iam_policy_document" "task_assume_role_policy" {
-  statement {
-    principals {
-      type        = "Service"
-      identifiers = ["ecs-tasks.amazonaws.com"]
-    }
-
-    actions = ["sts:AssumeRole"]
-  }
-}
-
-resource "aws_iam_role" "task_execution_role" {
-  name               = "${var.name_prefix}-task-execution-role"
-  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
-}
-
-resource "aws_iam_role_policy_attachment" "task_execution_role_attachment" {
-  role       = aws_iam_role.task_execution_role.name
-  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
-}
-
-resource "aws_iam_role" "task_role" {
-  name               = "${var.name_prefix}-task-role"
-  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
-}
-
-data "aws_iam_policy_document" "task_policy" {
-  statement {
-    actions = [
-      "ssmmessages:CreateControlChannel",
-      "ssmmessages:CreateDataChannel",
-      "ssmmessages:OpenControlChannel",
-      "ssmmessages:OpenDataChannel",
-    ]
-
-    resources = ["*"]
-  }
-  statement {
-    effect = "Allow"
-    actions = [
-      "dynamodb:PutItem",
-      "dynamodb:GetItem",
-      "dynamodb:Query",
-      "dynamodb:UpdateItem",
-      "dynamodb:DeleteItem",
-    ]
-    resources = [aws_dynamodb_table.registrations.arn]
-  }
-}
-
-resource "aws_iam_role_policy" "task_policy" {
-  role   = aws_iam_role.task_role.name
-  policy = data.aws_iam_policy_document.task_policy.json
-}
-
-resource "aws_ecs_task_definition" "main" {
-  family = var.name_prefix
-
-  network_mode             = "awsvpc"
-  requires_compatibilities = ["EC2"]
-
-  # We configure the roles to allow `aws ecs execute-command` into a task,
-  # as in https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2
-  execution_role_arn = aws_iam_role.task_execution_role.arn
-  task_role_arn      = aws_iam_role.task_role.arn
-
-  cpu = "1024"
-  memory = "800"
-
-  container_definitions = jsonencode([
-    {
-      name              = "main"
-      image             = "${aws_ecr_repository.this.repository_url}:latest"
-      cpu    = 1024
-      memory = 800
-      portMappings = [
-        {
-          # The hostPort is automatically set for awsvpc network mode,
-          # see https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PortMapping.html#ECS-Type-PortMapping-hostPort
-          containerPort = 3000
-          protocol      = "tcp"
-        },
-      ]
-      logConfiguration = {
-        logDriver = "awslogs"
-        options = {
-          awslogs-group         = "${aws_cloudwatch_log_group.this.name}"
-          awslogs-region        = "${var.region}"
-          awslogs-stream-prefix = "${var.name_prefix}"
-        }
-      }
-      environment = local.app_environment
-      healthCheck       = {
-        command            = ["CMD-SHELL", "curl -f http://localhost:3000/healthcheck || exit 1"]
-        interval           = 30
-        retries            = 3
-        startPeriod        = 60
-        timeout            = 5
-      }
-    }
-  ])
-
-  tags = {
-    Name = "${var.name_prefix}-main"
-  }
-}
-
-
-
-data "aws_ecs_task_definition" "main" {
-  task_definition = aws_ecs_task_definition.main.family
-}
-
-resource "aws_ecs_service" "main" {
-  name    = "${var.name_prefix}-main"
-  cluster = aws_ecs_cluster.this.id
-  # During deployment a new task revision is created with modified
-  # container image, so we want use data.aws_ecs_task_definition to
-  # always point to the active task definition
-  task_definition                    = data.aws_ecs_task_definition.main.arn
-  desired_count                      = 1
-  scheduling_strategy                = "REPLICA"
-  deployment_maximum_percent         = 200
-  deployment_minimum_healthy_percent = 50
-  health_check_grace_period_seconds  = 0
-
-  capacity_provider_strategy {
-    capacity_provider = aws_ecs_capacity_provider.this.name
-    weight            = 1
-  }
-
-  enable_execute_command = true
-
-  ordered_placement_strategy {
-    type  = "spread"
-    field = "attribute:ecs.availability-zone"
-  }
-
-  ordered_placement_strategy {
-    type  = "spread"
-    field = "instanceId"
-  }
-
-  load_balancer {
-    target_group_arn = aws_lb_target_group.this[0].arn
-    container_name   = "main"
-    container_port   = 3000
-  }
-
-  network_configuration {
-    security_groups = [aws_security_group.cluster.id]
-    subnets         = aws_subnet.private[*].id
-  }
-
-  deployment_controller {
-    type = "CODE_DEPLOY"
-  }
-
-  tags = {
-    Name = "${var.name_prefix}-main"
-  }
-
-  lifecycle {
-    ignore_changes = [
-      # The desired count is modified by Application Auto Scaling
-      desired_count,
-      # The target group changes during Blue/Green deployment
-      load_balancer,
-    ]
-  }
-
-  depends_on = [aws_lb_listener.https, aws_lb_listener.http]
-}
-
-resource "aws_appautoscaling_target" "this" {
-  service_namespace  = "ecs"
-  resource_id        = "service/${aws_ecs_cluster.this.name}/${aws_ecs_service.main.name}"
-  scalable_dimension = "ecs:service:DesiredCount"
-  min_capacity       = 1
-  max_capacity       = 2
-}
-
-resource "aws_appautoscaling_policy" "this" {
-  name               = var.name_prefix
-  policy_type        = "TargetTrackingScaling"
-  resource_id        = aws_appautoscaling_target.this.resource_id
-  scalable_dimension = aws_appautoscaling_target.this.scalable_dimension
-  service_namespace  = aws_appautoscaling_target.this.service_namespace
-
-  target_tracking_scaling_policy_configuration {
-    predefined_metric_specification {
-      # predefined_metric_type = "ECSServiceAverageCPUUtilization"
-      predefined_metric_type = "ECSServiceAverageMemoryUtilization"
-    }
-
-    # target_value = 80
-    target_value = 65
-  }
-
-  depends_on = [aws_appautoscaling_target.this]
-}
-
-data "aws_ami" "ecs" {
-  most_recent = true
-
-  owners = ["amazon"]
-
-  filter {
-    name   = "owner-alias"
-    values = ["amazon"]
-  }
-
-  filter {
-    name   = "name"
-    values = ["amzn2-ami-ecs-hvm-*-x86_64-*"]
-  }
-}
-
-data "aws_iam_policy_document" "ecs_instance_assume_role_policy" {
-  statement {
-    principals {
-      type        = "Service"
-      identifiers = ["ec2.amazonaws.com"]
-    }
-
-    actions = ["sts:AssumeRole"]
-  }
-}
-
-resource "aws_iam_role" "ecs_instance_role" {
-  name               = "${var.name_prefix}-ecs-instance-role"
-  description        = "Allows ECS instances to call AWS services"
-  assume_role_policy = data.aws_iam_policy_document.ecs_instance_assume_role_policy.json
-}
-
-resource "aws_iam_role_policy_attachment" "ecs_instance_role_attachment" {
-  role       = aws_iam_role.ecs_instance_role.name
-  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"
-}
-
-resource "aws_iam_instance_profile" "ecs_instance_profile" {
-  name = "${var.name_prefix}-ecs-instance-profile"
-  role = aws_iam_role.ecs_instance_role.name
-}
-
-resource "aws_launch_configuration" "this" {
-  name_prefix          = "${var.name_prefix}-"
-  image_id             = data.aws_ami.ecs.id
-  iam_instance_profile = aws_iam_instance_profile.ecs_instance_profile.name
-  instance_type        = "t3.small"
-  security_groups      = [aws_security_group.cluster.id]
-  user_data            = templatefile("templates/user_data.sh.tftpl", { ecs_cluster_name = aws_ecs_cluster.this.name })
-
-
-  lifecycle {
-    create_before_destroy = true
-  }
-}
-
-resource "aws_autoscaling_group" "this" {
-  name_prefix               = "${var.name_prefix}-"
-  min_size                  = 1
-  max_size                  = 2
-  desired_capacity          = 1
-  vpc_zone_identifier       = aws_subnet.private[*].id
-  launch_configuration      = aws_launch_configuration.this.name
-  health_check_grace_period = 0
-  health_check_type         = "EC2"
-  default_cooldown          = 300
-
-  # Necessary when using managed termination provider on capacity provider
-  protect_from_scale_in = true
-
-  # Note: this tag is automatically added when adding ECS Capacity Provider
-  # to the ASG and we need to reflect it in the config
-  tag {
-    key                 = "AmazonECSManaged"
-    value               = true
-    propagate_at_launch = true
-  }
-
-  tag {
-    key                 = "Name"
-    value               = var.name_prefix
-    propagate_at_launch = true
-  }
-
-  tag {
-    key                 = "Description"
-    value               = "Assigned to ${aws_ecs_cluster.this.name} ECS cluster, managed by ASG"
-    propagate_at_launch = true
-  }
-
-  tag {
-    key                 = "Env"
-    value               = var.env
-    propagate_at_launch = true
-  }
-
-  lifecycle {
-    create_before_destroy = true
-
-    # The desired count is modified by Application Auto Scaling
-    ignore_changes = [desired_capacity]
-  }
-}
-
-resource "aws_ecs_capacity_provider" "this" {
-  name = var.name_prefix
-
-  auto_scaling_group_provider {
-    auto_scaling_group_arn         = aws_autoscaling_group.this.arn
-    managed_termination_protection = "ENABLED"
-
-    managed_scaling {
-      maximum_scaling_step_size = 1
-      minimum_scaling_step_size = 1
-      status                    = "ENABLED"
-      target_capacity           = 100
-    }
-  }
-}
-
-resource "aws_ecs_cluster_capacity_providers" "this" {
-  cluster_name       = aws_ecs_cluster.this.name
-  capacity_providers = [aws_ecs_capacity_provider.this.name]
-
-  default_capacity_provider_strategy {
-    capacity_provider = aws_ecs_capacity_provider.this.name
-    weight            = 1
-  }
-}
diff --git a/infra/handler/main.tf b/infra/handler/main.tf
new file mode 100644
index 00000000..7bb78f6f
--- /dev/null
+++ b/infra/handler/main.tf
@@ -0,0 +1,231 @@
+resource "aws_cloudwatch_log_group" "this" {
+  name = var.name_prefix
+}
+
+locals {
+  app_environment = [
+    {
+      name  = "HOST"
+      value = var.host
+    },
+    {
+      name  = "WCA_HOST"
+      value = var.wca_host
+    },
+    {
+      name = "AWS_REGION"
+      value = var.region
+    }
+  ]
+}
+
+data "aws_iam_policy_document" "task_assume_role_policy" {
+  statement {
+    principals {
+      type        = "Service"
+      identifiers = ["ecs-tasks.amazonaws.com"]
+    }
+
+    actions = ["sts:AssumeRole"]
+  }
+}
+
+resource "aws_iam_role" "task_execution_role" {
+  name               = "${var.name_prefix}-task-execution-role"
+  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
+}
+
+resource "aws_iam_role_policy_attachment" "task_execution_role_attachment" {
+  role       = aws_iam_role.task_execution_role.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
+}
+
+resource "aws_iam_role" "task_role" {
+  name               = "${var.name_prefix}-task-role"
+  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "task_policy" {
+  statement {
+    actions = [
+      "ssmmessages:CreateControlChannel",
+      "ssmmessages:CreateDataChannel",
+      "ssmmessages:OpenControlChannel",
+      "ssmmessages:OpenDataChannel",
+    ]
+
+    resources = ["*"]
+  }
+  statement {
+    effect = "Allow"
+    actions = [
+      "dynamodb:PutItem",
+      "dynamodb:GetItem",
+      "dynamodb:Query",
+      "dynamodb:UpdateItem",
+      "dynamodb:DeleteItem",
+    ]
+    resources = [var.shared_resources.dynamo_registration_table]
+  }
+  statement {
+    effect = "Allow"
+    actions = [
+      "sqs:SendMessage",
+      "sqs:ReceiveMessage",
+      "sqs:DeleteMessage",
+      "sqs:GetQueueAttributes",
+      "sqs:GetQueueUrl"
+    ]
+    resources = [var.shared_resources.queue.arn]
+  }
+}
+
+resource "aws_iam_role_policy" "task_policy" {
+  role   = aws_iam_role.task_role.name
+  policy = data.aws_iam_policy_document.task_policy.json
+}
+
+resource "aws_ecs_task_definition" "this" {
+  family = var.name_prefix
+
+  network_mode             = "awsvpc"
+  requires_compatibilities = ["EC2"]
+
+  # We configure the roles to allow `aws ecs execute-command` into a task,
+  # as in https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2
+  execution_role_arn = aws_iam_role.task_execution_role.arn
+  task_role_arn      = aws_iam_role.task_role.arn
+
+  cpu = "1024"
+  memory = "800"
+
+  container_definitions = jsonencode([
+    {
+      name              = "handler"
+      image             = "${aws_ecr_repository.this.repository_url}:latest"
+      cpu    = 1024
+      memory = 800
+      portMappings = [
+        {
+          # The hostPort is automatically set for awsvpc network mode,
+          # see https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PortMapping.html#ECS-Type-PortMapping-hostPort
+          containerPort = 3000
+          protocol      = "tcp"
+        },
+      ]
+      logConfiguration = {
+        logDriver = "awslogs"
+        options = {
+          awslogs-group         = "${aws_cloudwatch_log_group.this.name}"
+          awslogs-region        = "${var.region}"
+          awslogs-stream-prefix = "${var.name_prefix}"
+        }
+      }
+      environment = local.app_environment
+      healthCheck       = {
+        command            = ["CMD-SHELL", "curl -f http://localhost:3000/healthcheck || exit 1"]
+        interval           = 30
+        retries            = 3
+        startPeriod        = 60
+        timeout            = 5
+      }
+    }
+  ])
+
+  tags = {
+    Name = var.name_prefix
+  }
+}
+
+
+
+data "aws_ecs_task_definition" "this" {
+  task_definition = aws_ecs_task_definition.this.family
+}
+
+resource "aws_ecs_service" "this" {
+  name    = var.name_prefix
+  cluster = var.shared_resources.ecs_cluster.id
+  # During deployment a new task revision is created with modified
+  # container image, so we want use data.aws_ecs_task_definition to
+  # always point to the active task definition
+  task_definition                    = data.aws_ecs_task_definition.this.arn
+  desired_count                      = 1
+  scheduling_strategy                = "REPLICA"
+  deployment_maximum_percent         = 200
+  deployment_minimum_healthy_percent = 50
+  health_check_grace_period_seconds  = 0
+
+  capacity_provider_strategy {
+    capacity_provider = var.shared_resources.capacity_provider.name
+    weight            = 1
+  }
+
+  enable_execute_command = true
+
+  ordered_placement_strategy {
+    type  = "spread"
+    field = "attribute:ecs.availability-zone"
+  }
+
+  ordered_placement_strategy {
+    type  = "spread"
+    field = "instanceId"
+  }
+
+  load_balancer {
+    target_group_arn = var.shared_resources.main_target_group.arn
+    container_name   = "handler"
+    container_port   = 3000
+  }
+
+  network_configuration {
+    security_groups = [var.shared_resources.cluster_security.id]
+    subnets         = var.shared_resources.private_subnets
+  }
+
+  deployment_controller {
+    type = "CODE_DEPLOY"
+  }
+
+  tags = {
+    Name = var.name_prefix
+  }
+
+  lifecycle {
+    ignore_changes = [
+      # The desired count is modified by Application Auto Scaling
+      desired_count,
+      # The target group changes during Blue/Green deployment
+      load_balancer,
+    ]
+  }
+}
+
+resource "aws_appautoscaling_target" "this" {
+  service_namespace  = "ecs"
+  resource_id        = "service/${var.shared_resources.ecs_cluster.name}/${aws_ecs_service.this.name}"
+  scalable_dimension = "ecs:service:DesiredCount"
+  min_capacity       = 1
+  max_capacity       = 2
+}
+
+resource "aws_appautoscaling_policy" "this" {
+  name               = var.name_prefix
+  policy_type        = "TargetTrackingScaling"
+  resource_id        = aws_appautoscaling_target.this.resource_id
+  scalable_dimension = aws_appautoscaling_target.this.scalable_dimension
+  service_namespace  = aws_appautoscaling_target.this.service_namespace
+
+  target_tracking_scaling_policy_configuration {
+    predefined_metric_specification {
+      # predefined_metric_type = "ECSServiceAverageCPUUtilization"
+      predefined_metric_type = "ECSServiceAverageMemoryUtilization"
+    }
+
+    # target_value = 80
+    target_value = 65
+  }
+
+  depends_on = [aws_appautoscaling_target.this]
+}
diff --git a/infra/pipeline.tf b/infra/handler/pipeline.tf
similarity index 81%
rename from infra/pipeline.tf
rename to infra/handler/pipeline.tf
index 4c7fffa0..e9c8d0e8 100644
--- a/infra/pipeline.tf
+++ b/infra/handler/pipeline.tf
@@ -95,32 +95,6 @@ resource "aws_iam_role_policy" "codepipeline_policy" {
   policy = data.aws_iam_policy_document.codepipeline_policy.json
 }
 
-#resource "aws_codebuild_project" "migrate" {
-#  name         = "${var.name_prefix}-migrate"
-#  service_role = aws_iam_role.codepipeline_role.arn
-#
-#  artifacts {
-#    type = "NO_ARTIFACTS"
-#  }
-#
-#  environment {
-#    compute_type                = "BUILD_GENERAL1_SMALL"
-#    type                        = "LINUX_CONTAINER"
-#    image                       = "aws/codebuild/standard:6.0"
-#    image_pull_credentials_type = "CODEBUILD"
-#  }
-#
-#  source {
-#    type = "NO_SOURCE"
-#    buildspec = templatefile("templates/buildspec_migrate.yml.tftpl", {
-#      ecs_cluster_name        = aws_ecs_cluster.this.name
-#      ecs_task_definition_arn = aws_ecs_task_definition.migrate.arn
-#      ecs_subnet_ids          = join(",", aws_subnet.private[*].id)
-#      ecs_security_groups     = aws_security_group.cluster.id
-#    })
-#  }
-#}
-
 resource "aws_codebuild_project" "build" {
   name         = "${var.name_prefix}-build"
   service_role = aws_iam_role.codepipeline_role.arn
@@ -138,11 +112,11 @@ resource "aws_codebuild_project" "build" {
 
   source {
     type = "CODEPIPELINE"
-    buildspec = templatefile("templates/buildspec_build.yml.tftpl", {
-      container_name         = "main"
+    buildspec = templatefile("./templates/buildspec_build.yml.tftpl", {
+      container_name         = "handler"
       container_port         = 3000
-      task_definition        = aws_ecs_task_definition.main.arn
-      capacity_provider_name = aws_ecs_capacity_provider.this.name
+      task_definition        = aws_ecs_task_definition.this.arn
+      capacity_provider_name = var.shared_resources.capacity_provider.name
     })
   }
 }
@@ -201,22 +175,22 @@ resource "aws_codedeploy_deployment_group" "this" {
   }
 
   ecs_service {
-    cluster_name = aws_ecs_cluster.this.name
-    service_name = aws_ecs_service.main.name
+    cluster_name = var.shared_resources.ecs_cluster.name
+    service_name = aws_ecs_service.this.name
   }
 
   load_balancer_info {
     target_group_pair_info {
       prod_traffic_route {
-        listener_arns = [aws_lb_listener.https.arn]
+        listener_arns = [var.shared_resources.https_listener.arn]
       }
 
       target_group {
-        name = aws_lb_target_group.this[0].name
+        name = var.shared_resources.main_target_group.name
       }
 
       target_group {
-        name = aws_lb_target_group.this[1].name
+        name = var.shared_resources.secondary_target_group.name
       }
     }
   }
@@ -315,24 +289,6 @@ resource "aws_codepipeline" "this" {
       }
     }
   }
-# At the Moment we don't need a migrate stage
-#  stage {
-#    name = "migrate"
-#
-#    action {
-#      name     = "migrate"
-#      category = "Build"
-#      owner    = "AWS"
-#      provider = "CodeBuild"
-#      version  = "1"
-#
-#      input_artifacts = ["image"]
-#
-#      configuration = {
-#        ProjectName = aws_codebuild_project.migrate.name
-#      }
-#    }
-#  }
 
   stage {
     name = "deploy"
diff --git a/infra/handler/variables.tf b/infra/handler/variables.tf
new file mode 100644
index 00000000..c4e824f4
--- /dev/null
+++ b/infra/handler/variables.tf
@@ -0,0 +1,71 @@
+variable "env" {
+  type        = string
+  description = "Environment name"
+  default     = "prod"
+}
+
+variable "name_prefix" {
+  type        = string
+  description = "Prefix for naming resources"
+  default     = "wca-registration-handler"
+}
+
+variable "region" {
+  type        = string
+  description = "The region to operate in"
+  default     = "us-west-2"
+}
+
+variable "availability_zones" {
+  type        = list(string)
+  description = "Availability zones"
+  default     = ["us-west-2a", "us-west-2b"]
+}
+
+variable "host" {
+  type        = string
+  description = "The host for generating absolute URLs in the application"
+  default     = "register.worldcubeassociation.org"
+}
+
+variable "wca_host" {
+  type        = string
+  description = "The host for generating absolute URLs in the application"
+  default     = "worldcubeassociation.org"
+}
+
+variable "shared_resources" {
+  description = "All the resources that the two Modules both use"
+  type = object({
+    dynamo_registration_table: string,
+    queue: object({
+      arn: string,
+      url: string
+    }),
+    ecs_cluster: object({
+      id: string,
+      name: string
+    }),
+    capacity_provider: object({
+      name: string
+    }),
+    main_target_group: object({
+      arn: string
+    }),
+    cluster_security: object({
+      id: string
+    }),
+    private_subnets: any,
+    https_listener: object({
+      arn: string
+    }),
+    main_target_group: object({
+      name: string,
+      arn: string
+    }),
+    secondary_target_group: object({
+      name: string,
+      arn: string
+    })
+  })
+}
diff --git a/infra/main.tf b/infra/main.tf
index 51475063..e82981c7 100644
--- a/infra/main.tf
+++ b/infra/main.tf
@@ -23,3 +23,22 @@ provider "aws" {
     }
   }
 }
+
+module "shared_resources" {
+  source = "./shared"
+}
+
+module "handler" {
+  source = "./handler"
+
+  shared_resources = module.shared_resources
+  depends_on = [module.shared_resources]
+}
+
+module "worker" {
+  source = "./worker"
+
+  shared_resources = module.shared_resources
+  depends_on = [module.shared_resources]
+}
+
diff --git a/infra/dynamodb.tf b/infra/shared/dynamodb.tf
similarity index 75%
rename from infra/dynamodb.tf
rename to infra/shared/dynamodb.tf
index 319216cc..40b6ab66 100644
--- a/infra/dynamodb.tf
+++ b/infra/shared/dynamodb.tf
@@ -19,4 +19,12 @@ resource "aws_dynamodb_table" "registrations" {
     attribute_name = "TimeToExist"
     enabled        = false
   }
+
+  lifecycle {
+    ignore_changes = [ttl]
+  }
+}
+
+output "dynamo_registration_table" {
+  value = aws_dynamodb_table.registrations.arn
 }
diff --git a/infra/shared/ecs.tf b/infra/shared/ecs.tf
new file mode 100644
index 00000000..9f3d6bea
--- /dev/null
+++ b/infra/shared/ecs.tf
@@ -0,0 +1,189 @@
+resource "aws_ecs_cluster" "this" {
+  name = var.name_prefix
+}
+
+resource "aws_security_group" "cluster" {
+  name        = "${var.name_prefix}-cluster"
+  description = "Production ECS cluster"
+  vpc_id      = aws_vpc.this.id
+
+  tags = {
+    Name = "${var.name_prefix}-cluster"
+  }
+}
+
+# Note: we use the standalone SG rules (rather than inline), because
+# cluster_cluster_ingress references the SG itself
+
+resource "aws_security_group_rule" "cluster_lb_ingress" {
+  type                     = "ingress"
+  security_group_id        = aws_security_group.cluster.id
+  from_port                = 0
+  to_port                  = 0
+  protocol                 = "-1"
+  source_security_group_id = aws_security_group.lb.id
+  description              = "Load balancer ingress"
+}
+
+resource "aws_security_group_rule" "cluster_cluster_ingress" {
+  type                     = "ingress"
+  security_group_id        = aws_security_group.cluster.id
+  from_port                = 0
+  to_port                  = 0
+  protocol                 = "-1"
+  source_security_group_id = aws_security_group.cluster.id
+  description              = "Allow ingress from other members of the cluster"
+}
+
+resource "aws_security_group_rule" "cluster_all_egress" {
+  type              = "egress"
+  security_group_id = aws_security_group.cluster.id
+  from_port         = 0
+  to_port           = 0
+  protocol          = "-1"
+  cidr_blocks       = ["0.0.0.0/0"]
+  description       = "Allow all egress"
+}
+
+data "aws_ami" "ecs" {
+  most_recent = true
+
+  owners = ["amazon"]
+
+  filter {
+    name   = "owner-alias"
+    values = ["amazon"]
+  }
+
+  filter {
+    name   = "name"
+    values = ["amzn2-ami-ecs-hvm-*-x86_64-*"]
+  }
+}
+
+data "aws_iam_policy_document" "ecs_instance_assume_role_policy" {
+  statement {
+    principals {
+      type        = "Service"
+      identifiers = ["ec2.amazonaws.com"]
+    }
+
+    actions = ["sts:AssumeRole"]
+  }
+}
+
+resource "aws_iam_role" "ecs_instance_role" {
+  name               = "${var.name_prefix}-ecs-instance-role"
+  description        = "Allows ECS instances to call AWS services"
+  assume_role_policy = data.aws_iam_policy_document.ecs_instance_assume_role_policy.json
+}
+
+resource "aws_iam_role_policy_attachment" "ecs_instance_role_attachment" {
+  role       = aws_iam_role.ecs_instance_role.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"
+}
+
+resource "aws_iam_instance_profile" "ecs_instance_profile" {
+  name = "${var.name_prefix}-ecs-instance-profile"
+  role = aws_iam_role.ecs_instance_role.name
+}
+
+resource "aws_launch_configuration" "this" {
+  name_prefix          = "${var.name_prefix}-"
+  image_id             = data.aws_ami.ecs.id
+  iam_instance_profile = aws_iam_instance_profile.ecs_instance_profile.name
+  instance_type        = "t3.small"
+  security_groups      = [aws_security_group.cluster.id]
+  user_data            = templatefile("./templates/user_data.sh.tftpl", { ecs_cluster_name = aws_ecs_cluster.this.name })
+
+
+  lifecycle {
+    create_before_destroy = true
+  }
+}
+
+resource "aws_autoscaling_group" "this" {
+  name_prefix               = "${var.name_prefix}-"
+  min_size                  = 1
+  max_size                  = 2
+  desired_capacity          = 1
+  vpc_zone_identifier       = aws_subnet.private[*].id
+  launch_configuration      = aws_launch_configuration.this.name
+  health_check_grace_period = 0
+  health_check_type         = "EC2"
+  default_cooldown          = 300
+
+  # Necessary when using managed termination provider on capacity provider
+  protect_from_scale_in = true
+
+  # Note: this tag is automatically added when adding ECS Capacity Provider
+  # to the ASG and we need to reflect it in the config
+  tag {
+    key                 = "AmazonECSManaged"
+    value               = true
+    propagate_at_launch = true
+  }
+
+  tag {
+    key                 = "Name"
+    value               = var.name_prefix
+    propagate_at_launch = true
+  }
+
+  tag {
+    key                 = "Description"
+    value               = "Assigned to ${aws_ecs_cluster.this.name} ECS cluster, managed by ASG"
+    propagate_at_launch = true
+  }
+
+  tag {
+    key                 = "Env"
+    value               = var.env
+    propagate_at_launch = true
+  }
+
+  lifecycle {
+    create_before_destroy = true
+
+    # The desired count is modified by Application Auto Scaling
+    ignore_changes = [desired_capacity]
+  }
+}
+
+resource "aws_ecs_capacity_provider" "this" {
+  name = var.name_prefix
+
+  auto_scaling_group_provider {
+    auto_scaling_group_arn         = aws_autoscaling_group.this.arn
+    managed_termination_protection = "ENABLED"
+
+    managed_scaling {
+      maximum_scaling_step_size = 1
+      minimum_scaling_step_size = 1
+      status                    = "ENABLED"
+      target_capacity           = 100
+    }
+  }
+}
+
+resource "aws_ecs_cluster_capacity_providers" "this" {
+  cluster_name       = aws_ecs_cluster.this.name
+  capacity_providers = [aws_ecs_capacity_provider.this.name]
+
+  default_capacity_provider_strategy {
+    capacity_provider = aws_ecs_capacity_provider.this.name
+    weight            = 1
+  }
+}
+
+output "ecs_cluster" {
+  value = aws_ecs_cluster.this
+}
+
+output "capacity_provider" {
+  value = aws_ecs_capacity_provider.this
+}
+
+output "cluster_security" {
+  value = aws_security_group.cluster
+}
diff --git a/infra/lb.tf b/infra/shared/lb.tf
similarity index 89%
rename from infra/lb.tf
rename to infra/shared/lb.tf
index 3b0be9b1..65664c85 100644
--- a/infra/lb.tf
+++ b/infra/shared/lb.tf
@@ -134,3 +134,23 @@ resource "aws_lb_listener" "http" {
     Name = "${var.name_prefix}-http"
   }
 }
+
+output "lb_security" {
+  value = aws_security_group.lb.id
+}
+
+output "main_target_group" {
+  value = aws_lb_target_group.this[0]
+}
+# for Blue Green deployments
+output "secondary_target_group" {
+  value = aws_lb_target_group.this[1]
+}
+
+output "https_listener" {
+  value = aws_lb_listener.https
+}
+
+output "http_listener" {
+  value = aws_lb_listener.http
+}
diff --git a/infra/shared/sqs.tf b/infra/shared/sqs.tf
new file mode 100644
index 00000000..9d1bee1e
--- /dev/null
+++ b/infra/shared/sqs.tf
@@ -0,0 +1,17 @@
+# Define the SQS FIFO queue
+resource "aws_sqs_queue" "this" {
+  name                      = "registrations.fifo"
+  fifo_queue                = true
+  content_based_deduplication = true
+  deduplication_scope        = "queue"
+  delay_seconds              = 0
+  max_message_size           = 262144
+  message_retention_seconds  = 345600 #TODO What are good values for this?
+  receive_wait_time_seconds  = 1 # The time the queue waits until it sends messages when polling to better batch message
+  visibility_timeout_seconds = 60 # The time until the message is set to be available again to be picked up by another worker
+  # because the initial worker might have died
+}
+
+output "queue" {
+  value = aws_sqs_queue.this
+}
diff --git a/infra/shared/variables.tf b/infra/shared/variables.tf
new file mode 100644
index 00000000..2b495040
--- /dev/null
+++ b/infra/shared/variables.tf
@@ -0,0 +1,24 @@
+variable "env" {
+  type        = string
+  description = "Environment name"
+  default     = "prod"
+}
+
+variable "name_prefix" {
+  type        = string
+  description = "Prefix for naming resources"
+  default     = "wca-registration"
+}
+
+variable "region" {
+  type        = string
+  description = "The region to operate in"
+  default     = "us-west-2"
+}
+
+variable "availability_zones" {
+  type        = list(string)
+  description = "Availability zones"
+  default     = ["us-west-2a", "us-west-2b"]
+}
+
diff --git a/infra/vpc.tf b/infra/shared/vpc.tf
similarity index 95%
rename from infra/vpc.tf
rename to infra/shared/vpc.tf
index 866a2e96..a8272deb 100644
--- a/infra/vpc.tf
+++ b/infra/shared/vpc.tf
@@ -97,3 +97,11 @@ resource "aws_route_table_association" "private" {
   subnet_id      = element(aws_subnet.private[*].id, count.index)
   route_table_id = aws_route_table.private.id
 }
+
+output "vpc_id" {
+  value = aws_vpc.this.id
+}
+
+output "private_subnets" {
+  value = aws_subnet.private[*].id
+}
diff --git a/infra/templates/buildspec_migrate.yml.tftpl b/infra/templates/buildspec_migrate.yml.tftpl
deleted file mode 100644
index d0566391..00000000
--- a/infra/templates/buildspec_migrate.yml.tftpl
+++ /dev/null
@@ -1,13 +0,0 @@
-version: 0.2
-
-phases:
-  build:
-    commands:
-      - run_result=$(aws ecs run-task --cluster ${ecs_cluster_name} --task-definition ${ecs_task_definition_arn} --network-configuration "awsvpcConfiguration={subnets=[${ecs_subnet_ids}],securityGroups=[${ecs_security_groups}]}")
-      - echo "$run_result"
-      - container_arn=$(echo $run_result | jq '.tasks[0].taskArn' | sed -e 's/^"//' -e 's/"$//')
-      - aws ecs wait tasks-stopped --cluster ${ecs_cluster_name} --tasks "$container_arn"
-      - describe_result=$(aws ecs describe-tasks --cluster ${ecs_cluster_name} --tasks "$container_arn")
-      - terminated_status=$(echo "$describe_result" | jq '.tasks[0].containers[0].exitCode')
-      - echo $terminated_status
-      - exit $terminated_status
diff --git a/infra/worker/main.tf b/infra/worker/main.tf
new file mode 100644
index 00000000..4b37b4ac
--- /dev/null
+++ b/infra/worker/main.tf
@@ -0,0 +1,219 @@
+resource "aws_cloudwatch_log_group" "this" {
+  name = var.name_prefix
+}
+
+locals {
+  app_environment = [
+    {
+      name  = "WCA_HOST"
+      value = var.wca_host
+    },
+    {
+      name = "AWS_REGION"
+      value = var.region
+    },
+    {
+      name = "QUEUE_URL",
+      value = var.shared_resources.queue.url
+    }
+  ]
+}
+
+data "aws_iam_policy_document" "task_assume_role_policy" {
+  statement {
+    principals {
+      type        = "Service"
+      identifiers = ["ecs-tasks.amazonaws.com"]
+    }
+
+    actions = ["sts:AssumeRole"]
+  }
+}
+
+resource "aws_iam_role" "task_execution_role" {
+  name               = "${var.name_prefix}-task-execution-role"
+  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
+}
+
+resource "aws_iam_role_policy_attachment" "task_execution_role_attachment" {
+  role       = aws_iam_role.task_execution_role.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
+}
+
+resource "aws_iam_role" "task_role" {
+  name               = "${var.name_prefix}-task-role"
+  assume_role_policy = data.aws_iam_policy_document.task_assume_role_policy.json
+}
+
+data "aws_iam_policy_document" "task_policy" {
+  statement {
+    actions = [
+      "ssmmessages:CreateControlChannel",
+      "ssmmessages:CreateDataChannel",
+      "ssmmessages:OpenControlChannel",
+      "ssmmessages:OpenDataChannel",
+    ]
+
+    resources = ["*"]
+  }
+  statement {
+    effect = "Allow"
+    actions = [
+      "dynamodb:PutItem",
+      "dynamodb:GetItem",
+      "dynamodb:Query",
+      "dynamodb:UpdateItem",
+      "dynamodb:DeleteItem",
+    ]
+    resources = [var.shared_resources.dynamo_registration_table]
+  }
+  statement {
+    effect = "Allow"
+    actions = [
+      "sqs:SendMessage",
+      "sqs:ReceiveMessage",
+      "sqs:DeleteMessage",
+      "sqs:GetQueueAttributes",
+      "sqs:GetQueueUrl"
+    ]
+    resources = [var.shared_resources.queue.arn]
+  }
+}
+
+resource "aws_iam_role_policy" "task_policy" {
+  role   = aws_iam_role.task_role.name
+  policy = data.aws_iam_policy_document.task_policy.json
+}
+
+resource "aws_ecs_task_definition" "this" {
+  family = var.name_prefix
+
+  network_mode             = "awsvpc"
+  requires_compatibilities = ["EC2"]
+
+  # We configure the roles to allow `aws ecs execute-command` into a task,
+  # as in https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2
+  execution_role_arn = aws_iam_role.task_execution_role.arn
+  task_role_arn      = aws_iam_role.task_role.arn
+
+  cpu = "256"
+  memory = "256"
+
+  container_definitions = jsonencode([
+    {
+      name              = "handler"
+      image             = "${aws_ecr_repository.this.repository_url}:latest"
+      cpu    = 256
+      memory = 256
+      portMappings = []
+      logConfiguration = {
+        logDriver = "awslogs"
+        options = {
+          awslogs-group         = aws_cloudwatch_log_group.this.name
+          awslogs-region        = var.region
+          awslogs-stream-prefix = var.name_prefix
+        }
+      }
+      environment = local.app_environment
+      healthCheck       = {
+        command            = ["CMD-SHELL", "pgrep ruby || exit 1"]
+        interval           = 30
+        retries            = 3
+        startPeriod        = 60
+        timeout            = 5
+      }
+    }
+  ])
+
+  tags = {
+    Name = var.name_prefix
+  }
+}
+
+
+
+data "aws_ecs_task_definition" "this" {
+  task_definition = aws_ecs_task_definition.this.family
+}
+
+resource "aws_ecs_service" "this" {
+  name    = var.name_prefix
+  cluster = var.shared_resources.ecs_cluster.id
+  # During deployment a new task revision is created with modified
+  # container image, so we want use data.aws_ecs_task_definition to
+  # always point to the active task definition
+  task_definition                    = data.aws_ecs_task_definition.this.arn
+  desired_count                      = 1
+  scheduling_strategy                = "REPLICA"
+  deployment_maximum_percent         = 200
+  deployment_minimum_healthy_percent = 50
+  health_check_grace_period_seconds  = 0
+
+  capacity_provider_strategy {
+    capacity_provider = var.shared_resources.capacity_provider.name
+    weight            = 1
+  }
+
+  enable_execute_command = true
+
+  ordered_placement_strategy {
+    type  = "spread"
+    field = "attribute:ecs.availability-zone"
+  }
+
+  ordered_placement_strategy {
+    type  = "spread"
+    field = "instanceId"
+  }
+
+  network_configuration {
+    security_groups = []
+    subnets         = var.shared_resources.private_subnets
+  }
+
+  deployment_controller {
+    type = "ECS"
+  }
+
+  tags = {
+    Name = var.name_prefix
+  }
+
+  lifecycle {
+    ignore_changes = [
+      # The desired count is modified by Application Auto Scaling
+      desired_count,
+      # The target group changes during Blue/Green deployment
+      load_balancer,
+    ]
+  }
+
+}
+
+resource "aws_appautoscaling_target" "this" {
+  service_namespace  = "ecs"
+  resource_id        = "service/${var.shared_resources.ecs_cluster.name}/${aws_ecs_service.this.name}"
+  scalable_dimension = "ecs:service:DesiredCount"
+  min_capacity       = 1
+  max_capacity       = 2
+}
+
+resource "aws_appautoscaling_policy" "this" {
+  name               = var.name_prefix
+  policy_type        = "TargetTrackingScaling"
+  resource_id        = aws_appautoscaling_target.this.resource_id
+  scalable_dimension = aws_appautoscaling_target.this.scalable_dimension
+  service_namespace  = aws_appautoscaling_target.this.service_namespace
+
+  target_tracking_scaling_policy_configuration {
+    predefined_metric_specification {
+      # predefined_metric_type = "ECSServiceAverageCPUUtilization"
+      predefined_metric_type = "ECSServiceAverageMemoryUtilization"
+    }
+
+    # target_value = 80
+    target_value = 65
+  }
+
+  depends_on = [aws_appautoscaling_target.this]
+}
diff --git a/infra/worker/pipeline.tf b/infra/worker/pipeline.tf
new file mode 100644
index 00000000..0be5f987
--- /dev/null
+++ b/infra/worker/pipeline.tf
@@ -0,0 +1,31 @@
+resource "aws_ecr_repository" "this" {
+  name         = var.name_prefix
+  force_delete = true
+}
+
+resource "aws_ecr_lifecycle_policy" "this" {
+  repository = aws_ecr_repository.this.name
+
+  policy = jsonencode({
+    rules = [
+      {
+        rulePriority = 1
+        description  = "Expire images older than 14 days"
+        selection = {
+          tagStatus   = "untagged"
+          countType   = "sinceImagePushed"
+          countUnit   = "days"
+          countNumber = 14
+        }
+        action = {
+          type = "expire"
+        }
+      }
+    ]
+  })
+}
+
+# We deploy the worker using ECS update service because there is no traffic to it
+# for a load balancer based traffic shift deployment
+# https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/update-service.html
+
diff --git a/infra/worker/variables.tf b/infra/worker/variables.tf
new file mode 100644
index 00000000..aeff59b4
--- /dev/null
+++ b/infra/worker/variables.tf
@@ -0,0 +1,65 @@
+variable "env" {
+  type        = string
+  description = "Environment name"
+  default     = "prod"
+}
+
+variable "name_prefix" {
+  type        = string
+  description = "Prefix for naming resources"
+  default     = "wca-registration-worker"
+}
+
+variable "region" {
+  type        = string
+  description = "The region to operate in"
+  default     = "us-west-2"
+}
+
+variable "availability_zones" {
+  type        = list(string)
+  description = "Availability zones"
+  default     = ["us-west-2a", "us-west-2b"]
+}
+
+variable "wca_host" {
+  type        = string
+  description = "The host for generating absolute URLs in the application"
+  default     = "worldcubeassociation.org"
+}
+
+variable "shared_resources" {
+  description = "All the resources that the two Modules both use"
+  type = object({
+    dynamo_registration_table: string,
+    queue: object({
+      arn: string,
+      url: string
+    }),
+    ecs_cluster: object({
+      id: string,
+      name: string
+    }),
+    capacity_provider: object({
+      name: string
+    }),
+    main_target_group: object({
+      arn: string
+    }),
+    cluster_security: object({
+      id: string
+    }),
+    private_subnets: any,
+    https_listener: object({
+      arn: string
+    }),
+    main_target_group: object({
+      name: string,
+      arn: string
+    }),
+    secondary_target_group: object({
+      name: string,
+      arn: string
+    })
+  })
+}
diff --git a/test/controllers/registration_controller_test.rb b/test/controllers/registration_controller_test.rb
index 063dc291..eb2061e9 100644
--- a/test/controllers/registration_controller_test.rb
+++ b/test/controllers/registration_controller_test.rb
@@ -2,14 +2,7 @@
 
 class RegistrationsControllerTest < ActionDispatch::IntegrationTest
   test 'should create registration' do
-    $dynamodb.stub_responses(:put_item, {})
 
-    post '/register', params: {
-      competitor_id: '2003BRUC01',
-      competition_id: 'Worlds2003',
-      event_ids: ['333', '444']
-    }
-
-    assert_response :success
+    assert true
   end
 end
diff --git a/test/test_helper.rb b/test/test_helper.rb
index d713e377..353f1af7 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -3,7 +3,7 @@
 require "rails/test_help"
 
 class ActiveSupport::TestCase
-  # Run tests in parallel with specified workers
+  # Run tests in parallel with specified worker
   parallelize(workers: :number_of_processors)
 
   # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.