Extending Your Application

The Milesoft Platform is engineered as a highly modular, plug-and-play application ecosystem. Rather than writing complex integrations, database drivers, or notification routers from scratch, developers can instantly extend their bootstrapped applications using our pre-built, strongly-typed Client SDKs and Cloud Infrastructure Extensions.

This guide outlines our full ecosystem and provides concrete architectural examples of why and how you would choose to incorporate them into your custom application.

The Extension Ecosystem at a Glance

Our ecosystem is divided into two primary categories, available as secure Maven dependencies hosted in our Google Cloud Artifact Registry:

  1. Client SDKs: Programmatic Java clients designed to interact directly with Milesoft's centralized microservices (Identity, Contacts Graph, Gamification, Templates, and Messaging).
  2. Infrastructure & Integration Extensions: Highly optimized Spring Boot libraries that integrate cloud databases, queue systems, AI pipelines, media SaaS, and payment processors directly into your service runtime.
                  +-----------------------------------+
                  |      Custom Milesoft Application  |
                  +-----------------------------------+
                                    |
          +-------------------------+-------------------------+
          |                                                   |
          ▼                                                   ▼
+-------------------+                               +-------------------+
|    Client SDKs    |                               |    Extensions     |
| (Platform APIs)   |                               |  (Cloud & Third)  |
+-------------------+                               +-------------------+
  ├─ Accounts SDK                                     ├─ Firestore / PubSub / Storage
  ├─ Contacts SDK                                     ├─ Secrets / Task Queues
  ├─ Games SDK                                        ├─ OpenAI / Vertex AI / Cloudinary
  ├─ Liquid SDK                                       ├─ Stripe / QuickBooks / Square
  └─ Notifications SDK                                └─ Twilio / LinkedIn / OpenPOJO

1. Core Platform Client SDKs

Centralized microservices host major parts of our common business schemas. Rather than deploying these systems inside your own GCP footprint, you can invoke them programmatically via their respective Java SDKs.

1.1 Accounts SDK

  • What it does: Provides strongly-typed interfaces for user profile synchronization, subscriber tenant-account registrations, MFA challenge generation, role management, and SSO validation.
  • Why choose this:
    • To build secure multi-tenant B2B portals where clients can invite, manage, and elevate their own team members.
    • To store and update custom tenant branding properties (such as logos and primary hex colors) dynamically.

1.2 Contacts SDK

  • What it does: Interfaces with our high-density Graph Engine. It models people as nodes and their relationships (such as employer, spouse, or teammate) as edges with rich, filterable metadata.
  • Why choose this:
    • To construct interactive organizational charts, customer connection grids, or social referral networks.
    • To render high-fidelity relationship topologies dynamically as SVG vectors on your frontend.
  • Example apps: Used extensively in Milesoft Offerings and Milesoft Connections.

1.3 Games SDK

  • What it does: Powers the gamification engine. It automatically tracks levels, difficulty profiles, activity logs, median metrics, and permanent or rolling weekly leaderboards.
  • Why choose this:
    • To build user retention features, like giving daily points, achievement badges, or tracking campaign-progression ranks
  • Example apps: Used extensively in Milesoft Sudoku, Milesoft Words, and Milesoft Dots.

1.4 Liquid SDK

  • What it does: A low-latency compilation and execution client for Shopify Liquid layouts. Merges JSON data structures with stored layouts to produce beautifully compiled HTML, structured text, or PDFs.
  • Why choose this:
    • To generate custom PDFs (such as invoices, performance reports, or receipts) dynamically on client request.
    • To maintain and edit customer-facing notification templates in Cloud Storage without needing to redeploy backend application code.

1.5 Notifications SDK

  • What it does: A cross-channel message orchestrator that delivers alerts across Transactional Email, SMS, and Mobile Push Notifications.
  • Why choose this:
    • To notify users when critical actions occur (e.g., "Your report is ready," "A new user joined your account," or "Your subscription has been processed").
    • To automatically route notifications based on user preferences and channel availability.

2. Cloud Infrastructure Extensions

These libraries configure cloud-native primitives on Google Cloud Platform, simplifying database access, asynchronous messaging, and serverless compute scheduling.

2.1 Firestore Integration

  • What it does: Configures Google Cloud Firestore document databases with built-in multi-tenant isolation filters, Spring Caching integration, and transactional CRUD repositories.
  • Why choose this:
    • To store customized, schemaless document records, such as the Widget entity used in the customizing your app guide, with automatic data separation per subscriber tenant account.

2.2 IAM Integration

  • What it does: Programmatically inspects, grants, and revokes Identity & Access Management (IAM) role bindings for GCP resources.
  • Why choose this:
    • To automate GCP project-level resource provisioning, secure permissions management, and dynamic access control directly from your application logic.

2.3 Pub/Sub Integration

  • What it does: Provides spring-ready listener binders and publish triggers for Google Cloud Pub/Sub topics.
  • Why choose this:
    • To build event-driven, loosely coupled architectures (e.g., publishing a WIDGET_CREATED event that other microservices can asynchronously consume and process).

2.4 Secrets Management

  • What it does: Resolves configuration parameters from Google Cloud Secret Manager at application startup and decrypts proprietary secrets.
  • Why choose this:
    • To keep sensitive credentials (like third-party API keys) secure, audit-logged, and out of source control.

2.5 Storage Integration

  • What it does: Interacts with Google Cloud Storage bucket repositories, generating signed read/write URLs and isolating files per tenant.
  • Why choose this:
    • To allow users to securely upload and download proprietary files, images, PDFs, or profile avatars.

2.6 Task Queue Integration

  • What it does: Coordinates distributed queue workers via Google Cloud Tasks to execute deferred logic with automatic retries and rate limiting.
  • Why choose this:
    • To process heavy or slow processes in the background (such as compiling data exports, running AI cognitive analysis, or syncing massive external datasets) without blocking the active HTTP response thread.

3. Payments, E-Commerce, Intelligence, & Media Extensions

These third-party connectors bundle complex API handshakes into clean, inject-ready Spring beans.

3.1 Stripe Integration

  • What it does: Manages Stripe billing portals, parses incoming checkout webhooks, and orchestrates online credit card processing.
  • Why choose this:
    • To sell SaaS subscriptions, process one-time transactions, or offer pay-as-you-go credit scales.

3.2 QuickBooks Integration

  • What it does: Automates synchronization with Intuit QuickBooks Online ledger books.
  • Why choose this:
    • To automatically generate bookkeeping entries, record payments, and synchronize customer invoicing data.

3.3 Square Integration

  • What it does: Connects your digital software application with physical, in-person POS hardware terminals and registers.
  • Why choose this:
    • To process real-world credit cards and synchronize local inventory levels with brick-and-mortar storefronts.

3.4 OpenAI Integration & Vertex AI Integration

  • What it does: Integrates cognitive artificial intelligence engines (OpenAI GPT-4 or Google Gemini Pro) directly into your Java backend.
  • Why choose this:
    • To summarize documents, extract structural JSON data from raw text, classify client support tickets, generate predictive forecasts, or construct custom chat interfaces.

3.5 Twilio Integration

  • What it does: Configures transactional voice gateways and real-time interactive SMS communication nodes.
  • Why choose this:
    • To implement automated phone check-ins, configure text-to-join marketing programs, or build automated customer service text lines.

3.6 Cloudinary Integration

  • What it does: Simplifies the secure upload, classification, query, and transformation of media assets (images and videos) using the Cloudinary Java SDK.
  • Why choose this:
    • To support classification-based uploads for public (globally viewable) or authenticated (signed, token-restricted) media storage.
    • To apply programmatic image transformations (resizing, cropping, responsive design operations) on-the-fly.
    • To convert in-memory images (e.g. BufferedImage) into byte streams for direct uploading.

3.7 LinkedIn Integration

  • What it does: Simplifies and standardizes interaction with the LinkedIn REST API, wrapping low-level Rest.li endpoints to publish rich content, post text updates, and perform multi-step media uploads.
  • Why choose this:
    • To automate organization URN scoping and ensure all Rest.li headers (version pinning, protocols) are properly formatted.
    • To seamlessly publish rich media or multi-source images from local files, remote URLs, or memory-backed assets directly to LinkedIn feeds.

4. Testing & Developer Productivity Extensions

These developer-centric libraries streamline testing workflows, contract compliance, and test automation.

4.1 OpenPOJO Extension

  • What it does: A high-productivity unit testing utility built specifically to automate structural and behavioral validation of Plain Old Java Objects (POJOs) like DTOs, API models, and entities across the ecosystem.
  • Why choose this:
    • To automatically test getter, setter, equals, hashCode, and toString contracts for all POJOs/DTOs in a package using reflective package scans.
    • To enforce quality rules (like EqualsMustExistRule, HashCodeMustExistRule, ToStringMustExistRule) and filter out test runners or helper classes via custom reflection filters.

5. End-to-End Architectural Patterns

By combining these building blocks, you can implement enterprise-level features in a fraction of the time. Here are three typical production blueprints:

Blueprint A: The B2B SaaS Subscriptions Engine

  • Objective: Charge customers recurring fees to access your system, upload business reports, and download generated invoices.
  • Architecture Flow:
    1. The user logs in via the Accounts SDK.
    2. They purchase a subscription, processed via the Stripe Extension.
    3. The Stripe Webhook publishes an event via the Pub/Sub Extension.
    4. Your background worker listens, registers the active plan, and lets the user upload a report to Google Cloud Storage via the Storage Extension.
    5. The Liquid SDK compiles a formal transactional PDF invoice and stores it securely.
    6. The Notifications SDK emails a download link to the client.

Blueprint B: The AI-Powered Asset Auditor

  • Objective: A client uploads an image of a field asset (e.g., a utility pole or water meter), and your system automatically extracts serial numbers, logs its geolocation, and flags damage.
  • Architecture Flow:
    1. The mobile app uploads the asset photo to Google Cloud Storage using the Storage Extension.
    2. The upload trigger enqueues a background task in Google Cloud Tasks via the Task Queue Extension.
    3. The queue worker executes, retrieving the image and invoking a multimodal vision model through the Vertex AI Extension to analyze the image.
    4. Vertex AI returns structured JSON containing the serial number and damage classifications.
    5. The worker saves the audit findings in Cloud Firestore using the Firestore Extension.
    6. If severe damage is detected, the Notifications SDK instantly fires an SMS alert to field operators via Twilio.

Blueprint C: The Automated Social Media Publisher & Campaign Engine

  • Objective: A marketing team wants to upload campaign assets, transform and optimize images automatically, and schedule posts to LinkedIn with automated stakeholder notifications.
  • Architecture Flow:
    1. The marketing portal allows users to upload a raw promotional banner image.
    2. The backend uploads and manages the image via the Cloudinary Extension, applying responsive image cropping and transformations.
    3. The campaign scheduler enqueues a delayed social media posting task via the Task Queue Extension.
    4. At the scheduled post time, the task worker retrieves the post content and uses the LinkedIn Extension to publish text and transformed Cloudinary image URLs directly to the company's LinkedIn feed.
    5. The worker records the successful Rest.li publication ID (the post URN) to Cloud Firestore using the Firestore Extension.
    6. A validation confirmation is sent to internal stakeholders using the Notifications SDK.