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.
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.
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.
| Where | Who it’s for | What they do |
|---|---|---|
| travel.padi.com | Customers | Search & book dive trips (web) |
| Mobile app | Customers | Same booking flow on iOS / Android |
| business.padi.com | Dive operators | Manage resorts & liveaboards (the original operator portal) |
| extranet.padi.com | Dive operators | The newer operator portal |
| intranet.padi.com | PADI staff | Internal admin & operations |
| affiliate.padi.com | Affiliate partners | Affiliate program portal |
| Partner API | Resellers (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.
| Environment | Purpose | Hosted on | We can access? | Page |
|---|---|---|---|---|
| Production | The live site real customers use | AWS ยท PADI-owned | Yes | Production โ |
| Stage (NP) | Testing / QA before going live | AWS ยท PADI-owned | Yes | Stage โ |
| Dev | Developer environment | Not in PADI’s AWS ยท no access | No | โ |
| In-progress (dev2) | Shared work-in-progress | Not in PADI’s AWS ยท no access | No | โ |
| Stage CN | China QA variant | AWS (likely stopped) | โ | โ |
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.
| Account | What it holds | How 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. |
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
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.
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.
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.
Release flow
Where the code lives & how it ships
There’s one code repository. Two branches map to the two environments we run:
| Branch | Goes to | How it gets there |
|---|---|---|
develop | Stage (and Dev / In-progress) | Automated โ a command or a pull-request comment runs it |
stable | Production | Manual โ someone logs in and updates each server by hand |
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.
| Issue | What it means day to day |
|---|---|
| No production rollback | If 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 live | Nothing tracks which code version is currently running in production. You have to check the server. |
| Production is deployed by hand | Two servers updated one by one. Easy to miss a step; needs care (see runbooks). |
| Manual scaling drift | Servers 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 running | Some 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).
Backend API docs โ
API specifications, Swagger, and endpoint references for the backend.
In the repository, the source for this guide is documents/ENVIRONMENTS_AND_INFRASTRUCTURE.md, alongside ARCHITECTURE.md, infrastructure.md, DEPLOYMENT.md and CI.md.