Appaveli Platform

Under the hood of the AppaveliTech stack.

This is the architecture that powers Appaveli CodeMind, Appaveli Creator, Investor Agent, and future tools — built around Java core services, Python AI agents, and native mobile clients.

Overview

Platform, not just projects

AppaveliTech runs on a shared platform instead of one-off backends. Core services (auth, users, subscriptions) live in Java. AI features live in Python agents. Native apps in Swift and Kotlin sit on top, with C++ libraries for shared domain logic where it makes sense.

The goal: move fast as a solo dev without creating a mess. One platform. Multiple products. Clear boundaries.

🏗 Design principles
  • Separate accounts/data from AI/LLM logic
  • Reuse the same agents across web and mobile
  • Start web-first, then layer on native apps with IAP
  • Keep the stack “solo-dev maintainable”
Java · Python · C++ Swift · Kotlin VPS hosted
High-level view

System diagram

A single platform fans out into web tools, native apps, and internal CLIs — all talking to the same core services and AI agents. 

                   ┌─────────────────────────────┐
                   │        Client Apps          │
                   │                             │
                   │  • Web (JSP / Servlets)     │
                   │  • iOS (Swift / SwiftUI)    │
                   │  • Android (Kotlin)         │
                   │  • Internal CLIs            │
                   └──────────────▲──────────────┘
                                  │
                    Auth / Profiles / Subs / Data
                                  │
                   ┌──────────────┴──────────────┐
                   │    Java Core Services       │
                   │   (AppaveliCore backend)    │
                   │  • Auth + JWT               │
                   │  • Users / Profiles         │
                   │  • Subscriptions & IAP      │
                   │  • DB (Postgres/MySQL)      │
                   └──────────────▲──────────────┘
                                  │
                             Trusted JWT
                                  │
              AI requests         │
          ┌───────────────────────┴───────────────────────┐
          │              Python AI Agents                  │
          │                (FastAPI)                       │
          │  • CodeMind API                                │
          │  • Creator / Caption Agent                     │
          │  • Investor Agent                              │
          │  • Future agents (Fitness, etc.)               │
          └───────────────────────┬───────────────────────┘
                                  │
                       Shared logic (where needed)
                                  │
          ┌────────────────────────────────────────────────┐
          │           C++ Shared Mobile Libraries          │
          │   • Economics / calculator logic               │
          │   • Fitness formulas / domain rules            │
          │   • Used by Swift & Kotlin via bridges         │
          └────────────────────────────────────────────────┘
☕ Java Core Services

Java (on a private JVM) handles the stable bits: authentication, JWT, profiles, and subscription logic. This is the “identity and data” layer for AppaveliTech.

  • Auth service – login, registration, JWT issuance
  • User service – profiles, preferences
  • Subscription service – entitlements & IAP receipts
Tomcat REST APIs
🐍 Python AI Agents

FastAPI-based agents power AI features: code analysis, caption generation, portfolio breakdowns, and more. Each agent is its own service, but they follow a consistent contract.

  • Creator Agent – caption & hook generation
  • Investor Agent – portfolio & ticker analysis
  • CodeMind API – code analysis & refactors
FastAPI OpenAI under the hood
📱 Native Clients

Future Appaveli apps ship as fully native iOS and Android clients, hitting the same Java + Python backends. In-app purchases unlock premium tiers on mobile first.

  • Swift / SwiftUI on iOS
  • Kotlin on Android
  • JWT from Java → calls into Python
Mobile-first monetization
⚙️ C++ Core Logic

For calculation-heavy apps (like economics or fitness), shared C++ libraries keep core logic consistent across iOS and Android while staying independent from any single UI framework.

  • Compiled once, used twice
  • Bridged via Obj-C++ / JNI
Optional layer Performance & reuse
How it behaves

Example request flows

🔐 Login + use AI (Creator)
  1. User logs in via Java core at /api/auth/login.
  2. Java returns a signed JWT.
  3. Client (web or mobile) stores JWT.
  4. Client calls Python Creator Agent with Authorization: Bearer <JWT>.
  5. Python verifies token, generates captions via LLM, returns JSON.
  6. Optional “Save” goes back to Java to persist against the user.
📊 Calculations + AI explanation
  1. User enters numbers in a mobile app.
  2. Swift/Kotlin calls into a shared C++ library for instant local math.
  3. Result is displayed immediately.
  4. Optional AI “explain this result” call goes to a Python Agent.
  5. User can save scenarios via Java core services.
Why architect it this way?

Built for a solo dev running a platform

As a Director of Software Engineering, I care about architecture, not chaos. As a solo dev, I care about velocity. The Appaveli Platform is meant to balance both: a clean separation of concerns without over-engineering the stack.

If you’re an engineering leader, founder, or dev curious about how this evolves, you can follow the journey through the tools themselves — and the posts I write about Appaveli Mode.

See what’s currently running on this stack →