PADI Travel ยท Infrastructure Guide

Everything that runs PADI Travel, in one place

PADI Travel is the booking platform for scuba-diving holidays. A single backend powers several websites, a mobile app, and partner integrations. This guide maps the servers and services behind it โ€” one environment per page, so you can read about Production or Stage without the two getting mixed up.

2Environments we run (Stage & Production)
2AWS accounts involved
us-west-2AWS region (Oregon)
1Django backend serving everything

Start here

What PADI Travel is

PADI Travel sells two kinds of diving experiences: multi-day vacations (liveaboard cruises and dive-resort packages) and single-day adventures (fun dives, courses, snorkelling). Customers browse and book on the website or mobile app; dive operators manage their listings on a separate B2B portal; and partner companies (like Check24 and Klook) resell the same products through an integration API.

All of that is served by one application โ€” a Django (Python) backend that exposes web APIs. Every website and app talks to it. Understanding that backend and the servers it runs on is what this guide is about.

In plain terms: one engine, many storefronts. If something is slow or broken across several sites at once, the cause is almost always in this shared backend or its database.

The product

The portals & apps

These are the public faces of the platform. They look like separate products, but they all run on the same backend.

WhereWho it’s forWhat they do
travel.padi.comCustomersSearch & book dive trips (web)
Mobile appCustomersSame booking flow on iOS / Android
business.padi.comDive operatorsManage resorts & liveaboards (the original operator portal)
extranet.padi.comDive operatorsThe newer operator portal
intranet.padi.comPADI staffInternal admin & operations
affiliate.padi.comAffiliate partnersAffiliate program portal
Partner APIResellers (Check24, Klook)List & sell our trips on their own sites

The detailed frontend breakdown (which framework each site uses) lives in the Frontend overview โ†—.

Under the hood

The technology

The backend

  • LanguagePython 3.12, Django 5.2 (web framework) + DRF (for APIs)
  • Background jobsCelery 5 (scheduled & async tasks)
  • Main databasePostgreSQL with PostGIS (maps/geo)
  • SearchElasticsearch (live search & autosuggest)
  • Fast read storeOpenSearch (speeds up a few heavy pages)
  • Cache & queuesRedis

Where it runs

  • CloudAmazon Web Services (AWS), region us-west-2 (Oregon)
  • ServersEC2 virtual machines (Linux)
  • DatabasesAWS RDS / Aurora (managed PostgreSQL)
  • Files & imagesAWS S3 + CloudFront (CDN)
  • ProvisioningAnsible (config) & AWS CDK (some infra)

For API specs and Swagger, see the Backend API docs โ†—.

The map

Environments at a glance

An “environment” is a complete copy of the platform for a purpose. This is the only page that compares them side by side โ€” each environment then gets its own page with the full details.

EnvironmentPurposeHosted onWe can access?Page
ProductionThe live site real customers useAWS ยท PADI-ownedYesProduction โ†’
Stage (NP)Testing / QA before going liveAWS ยท PADI-ownedYesStage โ†’
DevDeveloper environmentNot in PADI’s AWS ยท no accessNoโ€”
In-progress (dev2)Shared work-in-progressNot in PADI’s AWS ยท no accessNoโ€”
Stage CNChina QA variantAWS (likely stopped)โ€”โ€”
The two that matter for us: Production and Stage

These are the AWS, PADI-owned environments you have access to. Dev and In-progress are not in PADI’s AWS account and we don’t have access to them โ€” they’re managed elsewhere and are out of scope for this guide.

Boundaries

Who owns what & access

This is the most useful orientation fact, and it isn’t obvious: the environments are split across two different hosting setups.

AWS ยท PADI-owned

Production and Stage run on AWS in the us-west-2 region. PADI owns the account; we have access. Everything in this guide’s Production and Stage pages lives here.

Connect with make ssh_to_prod, make ssh_to_celery_prod, make ssh_to_stage.

Not in PADI’s AWS ยท no access

Dev and In-progress are separate environments that are not part of PADI’s AWS account. They’re reached through automated tooling, but we have no direct access and their hosting is out of scope here.

This is why the rule of thumb is: “we only have access to Stage and Production.”

Easy to miss

There are two AWS accounts

PADI Travel does not live in a single AWS account. There are two: a main account that holds all the infrastructure, and a second “core prod” account that we only discovered from the code โ€” it never appears in the normal console view.

AccountWhat it holdsHow we know
441054594441
Main account (the console you see)
All Travel infrastructure: servers, databases, caches, search, file storage, the message queue (SQS), the serverless functions, and the deploy tooling. The AWS console; the SQS ARN in production.py:254; the gh_deploy CDK stack.
388221456699
“core prod” account (separate)
A shared EventBridge message bus, core.events.internal. The Travel backend sends translation events to it, crossing from the main account into this one. Found in code, not the console: the bus ARN is hard-coded in src/diviac/settings/production.py:253 as AWS_TRANSLATION_BUS.
Why it matters

Translation events cross from the main account into the core prod account (388221456699) โ€” an account that doesn’t show up in the normal view. To debug translation-event delivery you’ll need access to that account too. The only pointer to it is the ARN in production.py:253.

Reading key

How to read this guide

Throughout the Production and Stage pages, every service is colour-coded by where it actually runs. This is the single most important distinction:

AWS service Runs on the server (native) Runs in a container Outside service

AWS service

A managed service that lives in the AWS account โ€” a database, cache, file store, etc. You don’t log into a machine to find it; you manage it in the AWS console.

Native (on the server)

A program running directly on an EC2 server, started and supervised by Linux (systemd). Things like the web server (Nginx) and the app itself.

In a container

A program packaged in Docker, running on the server but isolated. In production these are managed one by one (there’s no orchestrator).

Outside service

A third-party service reached over the internet โ€” Stripe (payments), Cognito (login), Salesforce, and so on.

A quick badge key

You’ll see drift where the live setup differs from what the code says, to confirm where something needs checking on the box, and noted for facts worth flagging. They keep the guide honest about what’s verified vs. assumed.

The whole system

System architecture

One view of the entire platform, read surface-to-depth: who connects, the edge they pass through, the servers that run the app, the data underneath, and the outside services it depends on. Production and Stage are two sizings of this same shape โ€” each environment page has its own detailed version.

AWS service On the server Container Outside service

Cloudflare sits in front of travel.padi.com only; CloudFront serves images/assets on a parallel path. The EventBridge bus lives in the separate core prod account (see Two AWS accounts). Full per-environment diagrams: Production ยท Stage.

Detailed reference diagram

How Production and Stage differ, at a glance โ€” from the architecture reference.

100%Zoom, or open full screen, then scroll to explore. Vector diagram โ€” stays sharp at any size.
flowchart LR subgraph P["PRODUCTION"] pw["Web EC2 (m5a.8xlarge)"] pc["Celery EC2 (r6a.xlarge)"] pa["Aurora cluster<br/>writer + reader r1"] pd["5 docker containers"] end subgraph S["STAGE / NP"] sb["1 EC2 (t3a.xlarge)<br/>Django + Celery together"] sd["single RDS<br/>stage-padi-travel"] sdk["3 docker containers"] end pw -.->|"split into 2 boxes"| sb pc -.->|"merged into stage box"| sb pa -.->|"downgraded to 1 instance"| sd pd -.->|"no prometheus/node-exporter"| sdk

Release flow

Where the code lives & how it ships

There’s one code repository. Two branches map to the two environments we run:

BranchGoes toHow it gets there
developStage (and Dev / In-progress)Automated โ€” a command or a pull-request comment runs it
stableProductionManual โ€” someone logs in and updates each server by hand
Tests don’t deploy

The automated checks (CircleCI) only run tests and linting. They never deploy anything. Deploying is always a separate, deliberate step. The full process โ€” including the runbooks โ€” is on the Deployments page.

Be aware

Known issues & risks

A short, honest list of the things that make this platform riskier to operate than it should be. They’re here so nobody is surprised.

IssueWhat it means day to day
No production rollbackIf a release breaks something, there’s no one-click undo. The safer fix is to roll forward with a new release.
No record of what’s liveNothing tracks which code version is currently running in production. You have to check the server.
Production is deployed by handTwo servers updated one by one. Easy to miss a step; needs care (see runbooks).
Manual scaling driftServers are resized by hand and the infrastructure code isn’t always updated to match โ€” e.g. the live web server is bigger than the code claims.
Everything is “open”A single shared login; little audit trail of who changed what.
Unused services still runningSome monitoring containers (Kibana, Prometheus) run but do nothing useful โ€” leftover from earlier setups.

Go deeper

References & further reading

Frontend overview โ†—

How the websites and apps are built (frameworks, structure, conventions).

padi-travel-frontend-doc.spin.axelerant.tech

Backend API docs โ†—

API specifications, Swagger, and endpoint references for the backend.

padi-travel-api-docs.spin.axelerant.tech

In the repository, the source for this guide is documents/ENVIRONMENTS_AND_INFRASTRUCTURE.md, alongside ARCHITECTURE.md, infrastructure.md, DEPLOYMENT.md and CI.md.