ObjectBox Setup: Object Database for Mobile Apps

We often encounter a situation: an Android app stutters when doing bulk data inserts — writing 1000 objects via Room takes 15 seconds. The client loses users due to lag. ObjectBox solves this: native C++ implementation without SQL parsing delivers up to 10x speedup on write operations. In our practice, we integrated ObjectBox into an IoT tracker that saved 500 points every 5 minutes — write time dropped from 8 to 0.7 seconds. Development time savings: up to 2 weeks per project thanks to automatic codegen and no DAOs. Additionally, the object model reduces code volume by 30–40%, directly lowering development and maintenance costs.

We configure ObjectBox end-to-end, including models, reactive queries, and synchronization. We evaluate your project in one day — contact us to get started.

Why ObjectBox is faster than SQLite?

ObjectBox is an object database, not relational. No JOINs, no GROUP BY — but for working with object graphs (entities with relations) that's not needed. Benchmarks from ObjectBox show a 10x advantage over Room/SQLite on writes. In real projects, the gap depends on patterns: bulk inserts — 3–10x win, reads by ID — roughly equal. For IoT apps, trackers, game saves, filterable catalogs, ObjectBox is ideal. Development savings: up to 40% compared to traditional solutions.

How to set up ObjectBox in 3–5 days?

The setup process includes several steps:

1. Data schema analysis: identify entities and relations.
2. Entity design with relations (ToOne, ToMany).
3. Integration of BoxStore into the Application class.
4. Implementation of reactive queries via DataObserver.
5. Performance testing: measure write/read speed.
6. Deployment to app stores.

Below is a typical stack and code.

Connecting and Models

// build.gradle (app)
plugins {
    id("io.objectbox")
}

dependencies {
    implementation("io.objectbox:objectbox-kotlin:3.8.0")
}

@Entity
data class Task(
    @Id var id: Long = 0,
    var title: String = "",
    var description: String = "",
    var priority: Int = 0,
    var dueDate: Long = 0,
    var isCompleted: Boolean = false
) {
    val tags: ToMany<Tag> = toMany()
}

@Entity
data class Tag(
    @Id var id: Long = 0,
    var name: String = "",
    @Index var color: String = ""
)

@Id is a mandatory Long for internal ObjectBox ID. This is not a UUID or your business identifier — use a separate string field for server synchronization.

Initialization and BoxStore

// Application class
class MyApp : Application() {
    companion object {
        lateinit var boxStore: BoxStore
            private set
    }

    override fun onCreate() {
        super.onCreate()
        boxStore = MyObjectBox.builder()
            .androidContext(this)
            .name("tasks-db")
            .build()
    }
}

// Usage in ViewModel
class TaskViewModel : ViewModel() {
    private val taskBox: Box<Task> = MyApp.boxStore.boxFor(Task::class.java)

    val tasks: LiveData<List<Task>> = liveData(Dispatchers.IO) {
        val query = taskBox.query(Task_.isCompleted.equal(false))
            .order(Task_.priority, QueryBuilder.DESCENDING)
            .build()
        emitSource(query.subscribe().toLiveData())
    }
}

query.subscribe().toLiveData() — ObjectBox DataObserver automatically notifies when data in the box changes. This is a reactive subscription without extra code.

Queries via QueryBuilder

ObjectBox does not use string SQL. Queries via type-safe QueryBuilder with Properties — generated metaclasses (Task_, Tag_):

// Filtering with multiple conditions
val urgentTasks = taskBox.query(
    Task_.isCompleted.equal(false)
        .and(Task_.priority.greater(2))
        .and(Task_.dueDate.less(System.currentTimeMillis() + 86_400_000L))
)
    .order(Task_.dueDate)
    .build()
    .find()

// Full-text search — requires @Index(type = IndexType.VALUE) + FTS
val searchResults = taskBox.query(
    Task_.title.contains("meeting", StringOrder.CASE_INSENSITIVE)
)
    .build()
    .find()

No JOINs — relations via ToOne/ToMany. ObjectBox loads related objects lazy by default:

// ToMany loads on first access val taskTags = task.tags // lazy load, DB access 

ObjectBox Sync

Note: like Realm, ObjectBox offers a commercial synchronization server — ObjectBox Sync. Bidirectional sync, conflict resolution, delta updates. This is a separate product with a licensing model. We integrate Sync into your app turnkey.

How does ObjectBox Sync work?

ObjectBox Sync uses delta synchronization: only changed objects are transmitted, not the entire database. Conflict resolution is configurable: you can choose "last writer wins", "local priority", or custom logic. To start, just set up a Sync server and specify the URL in the client.

Comparison of ObjectBox and Room

Common Issues and Solutions

Why ObjectBox suits IoT apps?

IoT devices generate streaming time-series data: coordinates, sensor readings, logs. ObjectBox handles bulk inserts without delays, and reactive subscriptions instantly update the UI. In the tracker we built, writing 500 points per minute caused no lag — unlike Room, where GC led to freezes. ObjectBox is also available for Flutter and React Native, simplifying cross-platform development.

What's included in the work

• Object model design with relations
• BoxStore setup, codegen, index optimization
• Reactive query implementation (LiveData/Flow)
• ObjectBox Sync integration (if needed)
• Performance testing (before/after benchmarks)
• Documentation on schema and access
• 30-day support after delivery

Order ObjectBox setup for your mobile app — we guarantee results. For over 5 years we've been doing mobile development and delivered 50+ projects on ObjectBox and alternatives. Get an estimate — write to us!