Binary Cipher01 · Experience
Show the offer inside a product people understand.
Usage, billing, plans, devices, support, and eSIM flows give popup and dashboard propositions believable customer context.
Explore the live screens
Public AEP + AJO test appMake decisioning
Make decisioning
feel real.
A polished telecom sandbox for testing Adobe Experience Platform and Journey Optimizer through offers, identity, Assurance, commerce, support, eSIM activation, and notification flows.
See what is inside · 15 seconds
A real product shell for real Adobe testing.
Start in simulation mode, connect live Adobe services when ready, and move through customer-facing scenarios without rebuilding the demo app around every test.
A silent, captioned preview showing Aether Connect as a telecom product, its live dashboard, and the Adobe testing control center.
Inside Aether Connect
From customer moment to Adobe trace.
The interface makes technical signals visible at every layer—customer experience, decision request, identity, event, and validation session.
02 · Connect
Switch from simulation to live Adobe wiring.
Configure datastream, organization, surfaces, Edge host, profiles, and Web SDK modes from one control center.
See the setup path
03 · Validate
Trace identity, decisions, and commerce events.
Use Assurance sessions, test profiles, popup and banner surfaces, cart activity, and notification payloads in repeatable scenarios.
Watch the app tours
Everything the app can do.
This is not a thin API harness. It is a full product-shaped sandbox that lets teams test Adobe behavior inside a believable mobile experience.
Popup and dashboard offers mapped to AJO surfaces.
The app requests two distinct surfaces, one for a welcome popup and one for the home dashboard banner, so teams can validate multiple decision touchpoints in one run.
Simulation mode keeps the app useful without live Adobe credentials.
Even before a datastream is configured, the UI stays complete through seeded simulation offers, letting demos, QA, and UX reviews continue without blocking on setup.
Profile switching simulates stitched CRM, email, and phone identities.
The Adobe tab can swap between named test users or a custom profile and automatically emit identity-oriented events for AEP testing.
Deep-link or QR-based Assurance session connection is built in.
The app recognizes validation session IDs from query strings and also includes an Assurance scanner flow to support trace-heavy testing sessions.
Emulated, real Web SDK, and Launch-style modes are all represented.
Teams can treat the app as an offline-friendly simulator or wire it to the real `alloy.js` path and Launch embed behavior when they want richer browser debugging.
General event dispatch and commerce tracking are first-class behaviors.
Cart additions, purchases, identity login, and custom events are all part of the experience so XDM testing is not limited to a single happy-path event.
Webhook-style notification testing is already modeled.
AJO-triggered push concepts are represented through a listener topic, in-app banners, notification history, and demo payload controls.
Telecom product UX makes technical demos easier to understand.
Usage meters, invoice state, eSIM provisioning, speed diagnostics, support chat, and device merchandising give the Adobe flows a believable product shell.
Plan upgrades and hardware orders can be tested in one place.
The catalog includes both subscription plans and devices, then routes them through cart review and simulated processing to create stronger commerce test coverage.
Speed check and add-on flows make the dashboard feel operational.
Teams can walk through data warnings, boosters, diagnostics, and cross-sell moments instead of showing Adobe features in isolation.
The same product can be viewed as a PWA or a desktop-style operator console.
A built-in view toggle lets the project support mobile storytelling and broader operator walkthroughs without building a second demo app.
Anyone can inspect the implementation and run it locally.
Because the repository is public, the project works well for internal enablement, portfolio proof, demo handoff, and self-guided experimentation.
Screenshots from the live app.
These captures come from the running project so the page reflects the real interface, not a rewritten mockup.
Short navigation videos turned into gif tours.
These are the fastest way to understand how the app behaves without pulling the repo locally first.
Where this app is genuinely useful.
The utility is broader than one offer demo. This project can support teaching, troubleshooting, stakeholder storytelling, and reusable Adobe sandbox work.
Show AJO Experience Decisioning in a way non-developers can actually feel.
Marketers, architects, and leaders can see surfaces, banners, fallbacks, and response behavior inside a realistic app instead of interpreting raw JSON.
Validate datastream, surface, and Edge request wiring quickly.
The project is useful for checking whether decisions are arriving, whether credentials are correct, and whether a local proxy path is needed on Safari-like environments.
Teach teams how identity, offers, commerce, and notifications connect.
Because the app spans profile, support, Adobe controls, and transactions, it works well as a guided learning sandbox for cross-functional onboarding.
Use it as a trace-friendly sandbox for Adobe Assurance sessions.
Session linking and QR scanning make it easier to stage repeatable walkthroughs for debugging, validation, and shared troubleshooting.
Package a technical Adobe integration inside a polished product shell.
The project shows not only API knowledge but product thinking, information architecture, UX craft, and end-to-end scenario design.
Start from this app instead of rebuilding the shell for every sandbox.
The telecom framing can be adapted into other AEP/AJO demos, giving teams a reusable base for future decisioning experiments and training environments.
How to use it.
You can get value out of the app in two modes: as a simulation-first local sandbox or as a live Adobe-connected testing surface.
Run the app locally.
Clone the public repository, install dependencies, and start the Vite development server. The app is already useful in simulation mode before any Adobe credentials are added.
git clone https://github.com/kotisyamala/mobileAppAEPAJO.git
cd mobileAppAEPAJO
npm install
npm run dev -- --host 127.0.0.1 --port 4173Open the Adobe tab and add your sandbox values.
Use the in-app Adobe control center to set the Datastream ID, IMS Org ID, popup surface, dashboard surface, and optional local Edge proxy host, then save and sync.
Popup surface: mobileapp://aether-connect/reload-popup
Dashboard surface: mobileapp://aether-connect/dashboard-bannerOptionally preconfigure the app with `.env` values.
If you prefer configuration through files instead of the UI, the project supports a standard Vite `.env` path for datastream, org, surfaces, and Edge host values.
VITE_AEP_DATASTREAM_ID="your_datastream_id_here"
VITE_AEP_ORG_ID="your_org_id_here"
VITE_AJO_SURFACE_POPUP="mobileapp://aether-connect/reload-popup"
VITE_AJO_SURFACE_DASHBOARD="mobileapp://aether-connect/dashboard-banner"
VITE_AEP_EDGE_HOST="https://edge.adobedc.net"Walk the key test scenarios.
Start with the welcome popup and dashboard banner, then validate identity switching, Support chat, cart purchase events, webhook notifications, and Assurance tracing.
1. Usage tab for popup and banner offers
2. Adobe tab for credentials, identity, and Assurance
3. Plans and Cart for commerce events
4. Profile tab for eSIM provisioning story
Quick copy
Copy the local run commands.
The project is immediately demoable in simulation mode, which makes it a strong free sandbox even before a real Adobe environment is wired in.
Copied to clipboard.
Free public sandbox
Built to be free to explore, clone, run, and learn from.
Aether Connect is positioned here as a free public test app for anyone who wants a realistic Adobe Edge plus AJO Experience Decisioning playground without building the full UX shell from scratch. It is strong for personal learning, internal demos, architecture walkthroughs, QA rehearsals, and portfolio storytelling.
Public GitHub repo
Simulation mode included
Live Adobe wiring supported
Mobile and web views