Guides
Start typing to search…

Application Creation

How to create and deploy TelemetryOS applications using the Studio platform

Creating Your Applications

Creating an application in TelemetryOS is the process of building and deploying a screen application that runs on physical devices and in Studio.

Application Structure

A TelemetryOS application consists of:

  • Render View - The main display content that appears on devices
  • Settings View - Configuration interface in the admin portal (optional)
  • Workers - Background scripts for data sync and scheduled tasks (optional)
  • Containers - Docker containers for backend services (optional)

For detailed information on application architecture, see Mount Points.

Core Capabilities

TelemetryOS applications support:

  • Modern Web Stack - HTML/CSS/JS/React with standard web APIs
  • Hardware Integration - Camera, serial, GPIO, and sensor APIs
  • Storage Scopes - application, instance, device, and shared storage
  • Real-time Updates - Subscribe to configuration and data changes
  • Media Management - Access and display media library content
  • Playlist Control - Programmatic playlist navigation

For complete SDK reference, see SDK Documentation.

Application Creation Workflow

TelemetryOS application creation follows a structured workflow from initial scaffolding through deployment and device assignment.

Application Generation

The TelemetryOS CLI scaffolds new applications with best practices built in. The CLI generates complete React + TypeScript applications including:

  • Pre-configured mount points
  • Local development server
  • Hot module reload
  • SDK integration

CLI-generated applications include all necessary configuration files and project structure. See Generate New Application for CLI usage details.

Application Registration

After building application code, applications register with TelemetryOS Studio through three methods:

  • GitHub Repository - Git repository connection enables CI/CD deployment (recommended)
  • Git Repository - Generic Git provider support (GitLab, Bitbucket, self-hosted)
  • Upload Archive - ZIP file upload for manual deployment

Registration links application code to the TelemetryOS platform, enabling build and deployment workflows. See Defining Application for registration details.

Component Implementation

TelemetryOS applications consist of up to four component types:

  • Render View - Display UI (/render or /index.html) shown on devices
  • Settings View - Configuration interface (/settings or /settings.html) in admin portal
  • Workers - Background scripts for data processing (optional)
  • Containers - Docker containers for backend services (optional)

Components communicate through the SDK's storage and messaging APIs.

Storage and Communication

The Storage API enables data sharing between application components. Settings components write configuration data; render components subscribe to changes for real-time updates:

import { configure, store } from '@telemetryos/sdk';

configure('my-app');

// Settings writes configuration
await store().instance.set('city', 'New York');

// Render subscribes to changes
store().instance.subscribe('city', (city) => {
  updateDisplay(city);
});

Storage scopes (application, instance, device, shared) determine data visibility and persistence. See Storage API for complete documentation.

Testing and Validation

Applications support multiple testing environments:

  • Local Development - CLI development server (tos serve) provides local testing
  • Studio Preview - Platform preview with live reload capabilities
  • Device Testing - Test device deployment before production rollout

Testing validates application behavior, storage communication, and device compatibility. See Local Development for development workflow details.

Deployment Architecture

Git-to-Screen deployment enables automated application builds and deployments:

  • Code commits to Git repositories trigger automatic builds
  • TelemetryOS builds and packages applications automatically
  • Version publishing enables controlled deployment to device playlists
  • Instant rollback restores previous application versions when needed

Deployment automation eliminates manual build steps and ensures consistent application versions across device fleets.

Device Assignment

Applications deploy to devices through playlist assignment:

  • Applications add to playlists as resizable regions
  • Schedule configuration controls when applications display
  • Fallback content ensures displays never show blank states
  • Environment variables and secrets provide application-specific configuration
  • Device group targeting enables location-based or function-based deployment

Development Best Practices

  • Use staging branches - Test on staging devices before production
  • Implement error handling - Applications run 24/7 on devices
  • Log important events - Use console logging for debugging
  • Optimize performance - Minimize resource usage on devices
  • Handle offline scenarios - Devices may lose connectivity

Next Steps

Updated 21 days ago

What’s Next