Quickstarters
How to Build a Backend for WatchOS?

39min
Introduction
In this tutorial, you’ll discover how to build a backend for watchOS apps using Back4App. 
Whether you’re creating a WatchKit extension for your iPhone app or designing a standalone Apple Watch experience, Back4App simplifies your work by providing essential tools. 
You’ll integrate features like a secure database, Cloud Code Functions, real-time queries (Live Queries), and user authentication—all without managing your own servers.
You’ll also see how Back4App’s quick startup routine and easy-to-use environment allow you to focus on your watchOS apps functionality, rather than setting up servers. 
Along the way, you’ll learn to handle tasks such as scheduling jobs, setting up webhooks, and configuring push notifications. 
By the end, you’ll have a solid foundation to extend your watch apps or iOS applications for production-level needs, all while delivering seamless data synchronization (over an internet connection) between the WatchKit app and your backend.
Prerequisites
A Back4App account and a new Back4App project
 Getting Started with Back4app.
If you do not have an account, you can create one for free. Follow the guide above to get your project ready.
A watchOS/Xcode development environment
 You should have Xcode installed with the watchOS SDK. You can run and build your WatchKit extension on either a real Apple Watch or a simulator.
Parse Swift SDK
Use Swift Package Manager to install and configure the SDK for your watchOS or combined iOS apps.
Familiarity with Swift, Xcode, and Apple’s development ecosystem
 Apple Developer Documentation.
If you’re new to Apple platforms, spend some time exploring the watchOS and iOS docs before starting.
Make sure you meet these prerequisites before you begin. Having your Back4App project set up and your local watchOS environment ready will help you follow along smoothly.
Step 1 – Creating a New Project on Back4App and connecting
Why you need a Back4App project
A new Back4App project is essential for storing all data and running cloud code for your watchOS apps. This serves as the foundation of your backend.
Create your project
Log in to Back4App.
Click “New App” in the dashboard.
Name your app (e.g., “WatchOS-Backend-Tutorial”).
﻿
Install Parse Swift SDK
Add the Parse Swift dependency in your Package.swift or by using File → Swift Packages → Add Package Dependency in Xcode. Provide the URL:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Initialize Parse in your watchOS or shared code
In your WatchKit app’s startup code or in a shared file accessible by both your watchOS and iPhone app, initialize Parse:
Swift
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
@main
struct MyWatchApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APP_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
At this point, your watchOS app can communicate with the Back4App backend. Whether it's an independent Apple Watch app or a WatchKit extension paired with an iPhone app, all backend data flows through the Parse Swift SDK.
Step 2 – Setting Up the Database
1. Creating a Data Model
Back4App uses Parse Server’s schema-on-write feature. You can define tables (classes) in the Back4App Database section or let them be created automatically when objects are first saved. For instance, if your watch apps track health data, you might have a “HealthMetrics” class with fields like heartRate, steps, or workoutType.
2. Creating a Data Model using the AI Agent
Back4App’s AI Agent lets you describe your schema in plain language:
Open the AI Agent in your app dashboard.
Provide details like “Please set up a Watch Metrics class with fields: dailySteps (Number), heartRate (Number).”
The AI will create the schema for you automatically.
﻿
3. Reading and Writing Data using the SDK
Below is an example of saving and querying data from a watchOS app. Let’s suppose we have a HealthMetrics struct:
Swift
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
import ParseSwift

struct HealthMetrics: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var dailySteps: Int?
    var heartRate: Int?
}

// Saving data
func saveMetrics(steps: Int, heart: Int) async {
    var metrics = HealthMetrics()
    metrics.dailySteps = steps
    metrics.heartRate = heart

    do {
        let saved = try await metrics.save()
        print("Saved metrics: \(saved)")
    } catch {
        print("Error saving: \(error)")
    }
}

// Querying data
func fetchLatestMetrics() async {
    let query = HealthMetrics.query()
    do {
        let results = try await query.find()
        print("Fetched: \(results.count) items")
    } catch {
        print("Error fetching: \(error)")
    }
}
﻿
4. Reading and Writing Data using REST API
If needed, your watchOS or iOS apps can also send REST requests:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dailySteps": 8000, "heartRate": 75}' \
  https://parseapi.back4app.com/classes/HealthMetrics
﻿
5. Reading and Writing Data using GraphQL
Back4App also provides a GraphQL endpoint. For instance:
GraphQL
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
mutation {
  createHealthMetrics(input: {
    fields: {
      dailySteps: 7500
      heartRate: 70
    }
  }) {
    healthMetrics {
      objectId
      dailySteps
      heartRate
    }
  }
}
﻿
6. Working with Live Queries (optional)
If you need real-time data updates on your Apple Watch, enable Live Queries:
Turn on Live Queries under Server Settings in Back4App.
Configure the Live Query URL in your watchOS code:
Swift
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
ParseLiveQuery.configure(url: URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!)
﻿
Then subscribe to changes:
Swift
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
func subscribeMetricsUpdates() async throws {
    let subscription = HealthMetrics.query().subscribe()
    for try await event in subscription {
        switch event {
        case .created(let newData):
            print("New data: \(newData)")
        case .updated(let updatedData):
            print("Updated: \(updatedData)")
        default:
            break
        }
    }
}
﻿
Step 3 – Applying Security with ACLs and CLPs
1. Brief Overview
Back4App allows Access Control Lists (ACLs) and Class-Level Permissions (CLPs) to secure your database. For example, you might restrict certain metrics to the user who generated them or allow read access only to authenticated accounts.
2. Step-by-step Setup
Class-Level Permissions
Go to Database → Class → Security to define defaults (e.g., read-only for all, write for owners).
ACLs in Code
You can add ACLs to each object in your WatchKit or shared code. For instance:
Swift
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
if let user = User.current {
    var acl = ParseACL()
    acl.setReadAccess(user: user, value: true)
    acl.setWriteAccess(user: user, value: true)

    var metrics = HealthMetrics()
    metrics.ACL = acl
}
﻿
This ensures only the logged-in user can view or modify the HealthMetrics objects they create.
Step 4 – Writing Cloud Code Functions
1. Why Cloud Code
Cloud Code helps you run complex or confidential operations server-side, such as data validation, external API calls, or logging. This setup is useful for minimizing watchOS device workload and preserving battery life on the Apple Watch.
2. Example Function
In your main.js:
JS
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
Parse.Cloud.define('processMetrics', async (request) => {
  const { dailySteps, heartRate } = request.params;
  if (!dailySteps || !heartRate) {
    throw 'Missing parameters.';
  }
  // Example: Simple calculation
  return dailySteps * heartRate;
});
﻿
3. Deployment
Use the Back4App CLI to deploy:
Bash
b4a deploy
b4a deploy
﻿
4. Installing NPM Modules
If you need external libraries in your Cloud Code:
Add dependencies in package.json (within your Cloud Code folder).
Use require('your-lib') in main.js.
Step 5 – Configuring Authentication
1. Enable User Authentication
By default, the User class is ready in Back4App. Make sure “Enable Class-Level Permissions” is set correctly for user objects.
2. Code Samples
In Parse Swift, you might sign up a user from your watchOS code:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpNewUser(name: String, pass: String, mail: String) async {
    var newUser = User()
    newUser.username = name
    newUser.password = pass
    newUser.email = mail

    do {
        let signedUp = try await newUser.signUp()
        print("Sign Up successful: \(signedUp)")
    } catch {
        print("Error signing up: \(error)")
    }
}
﻿
3. Social Login
If you plan on integrating Apple, Google, or Facebook login in your watchOS or iPhone app, you can do so with the relevant Parse Swift social login features. See Back4App Docs for details.
Step 6 – Handling File Storage
1. Setting up File Storage
If your watch apps need to upload images, logs, or small data files, you can rely on ParseFile:
Swift
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
func uploadFile(data: Data, fileName: String) async {
    let file = ParseFile(name: fileName, data: data)
    do {
        let savedFile = try await file.save()
        print("Uploaded file: \(savedFile.url ?? "")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
﻿
2. Example
You might store workout images or daily progress snapshots:
Swift
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
let snapshotData = // ...some image data from watch screenshot
Task {
    await uploadFile(data: snapshotData, fileName: "workout.jpg")
}
﻿
3. Security Considerations
Review your file ACLs. By default, file URLs are accessible if someone obtains the direct link. You can secure or control file access via your parse server’s file configuration.
Step 7 – Email Verification and Password Reset
1. Overview
Apple Watch users may not always manage logins directly on the watch, but enabling email verification helps keep their data secure.
2. Back4App Dashboard Configuration
Go to App Settings → Email.
Turn on Email Verification.
Customize templates as needed.
3. Code/Implementation
For password resets:
Swift
do {
    try await User.requestPasswordReset(email: "[email protected]")
} catch {
    print("Error requesting password reset: \(error)")
}
do {
    try await User.requestPasswordReset(email: "example@domain.com")
} catch {
    print("Error requesting password reset: \(error)")
}
﻿
Step 8 – Scheduling Tasks with Cloud Jobs
1. What Cloud Jobs Do
Cloud Jobs let you automate background tasks like rotating old data or generating usage reports for your watchOS analytics.
2. Example
In main.js:
JS
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
Parse.Cloud.job('cleanUpMetrics', async (request) => {
  const query = new Parse.Query('HealthMetrics');
  // For example, remove records older than 7 days
  const now = new Date();
  const cutoff = new Date(now - 7 * 24 * 60 * 60 * 1000);
  query.lessThan('createdAt', cutoff);

  const oldMetrics = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldMetrics, { useMasterKey: true });
  return `Deleted ${oldMetrics.length} old records.`;
});
﻿
Deploy your code.
Go to App Settings → Server Settings → Background Jobs and schedule it daily.
Scheduling a Cloud Job
﻿
Step 9 – Integrating Webhooks
1. Definition
Webhooks notify external services when certain events happen in your app. For instance, you might want to ping a Slack channel every time a new metric is recorded.
2. Configuration
In the Back4App dashboard, go to More → Webhooks.
Add a webhook with an endpoint (like a Slack URL).
Choose the event (e.g., “New record in HealthMetrics”).
Adding a Webhook
﻿
3. Example
Whenever a user adds a new dailySteps entry, your Slack channel is notified. You can also define more complex logic in Cloud Code to send custom payloads to your external services.
Step 10 – Exploring the Back4App Admin Panel
1. Where to Find It
The Admin Panel is accessible via your Back4App console under More → Admin App.
Enable it and create an admin user for web-based data management if you need a straightforward interface for non-technical stakeholders.
Enable Admin App
﻿
2. Features
View and Edit Data
Manage logs and Cloud Jobs
Track analytics or push notifications
This is an easy way to collaborate on data without needing direct database or code access.
Conclusion
Throughout this guide, you learned how to build a backend for watchOS using Back4App’s powerful features. You set up a secure database schema, wrote Cloud Code, handled real-time queries, and implemented user authentication. Now your WatchKit app can store and sync data with minimal hassle.
Next Steps
Polish your watch apps by integrating advanced cloud functions for personalized notifications or data transformations.
Explore additional iOS applications functionalities, like background sync and caching strategies for your Apple Watch.
Read the official Back4App docs for more on advanced security, analytics, and performance.
Optimize for the App Store to distribute your watchOS extension or standalone watch app.
By expanding your backend, you can deliver robust watchOS apps that work seamlessly even with limited internet connection. Keep building and enjoy the power of Back4App for your Apple Watch experiences!
Updated 15 Jan 2025
Did this page help you?
How to Build a Backend for jQuery?
How to Build a Backend for tvOS?