Forem: Serhii Boboshko

I built a Jetpack Compose framework that auto-generates SQLite database and UI for your entities (ERP-style apps in minutes)

Serhii Boboshko — Wed, 08 Oct 2025 17:48:23 +0000

I’ve been building apps with Jetpack Compose for a while, and I was always frustrated by how much boilerplate I had to write — especially when dealing with entities, DAOs, ViewModels, and UI forms.

So I decided to create my own framework — ComposeEntity. It automatically generates the SQLite database and the full UI for your entities (with CRUD operations, navigation, and even reports). You just describe your data model — the framework takes care of the rest.

Think of it as a way to build ERP-like apps in minutes instead of days. No need for Room, no manual ViewModel wiring, no repetitive UI code — everything is generated automatically but still fully customizable.

Here’s a short video showing how it works 👇
(Video link)

I’d love to hear your thoughts, suggestions, or use cases you’d like to see supported next.

How I tried to bring Oracle/SAP/1C-style auto-generated forms into Android with Jetpack Compose + SQLite

Serhii Boboshko — Sun, 07 Sep 2025 11:12:56 +0000

I’ve spent part of my career working with enterprise systems like Oracle, SAP, 1C.
One thing they all have in common: you create a table, and if you don’t need heavy customization — you already get working forms for:

browsing lists
adding and editing records
marking for deletion
deleting or copying items

That always felt natural. You focus on your data and business logic, not on infrastructure.

The Android pain

When I switched to Android development, I ran into a wall.
Every time I wanted to try out a simple idea, I first had to:

define entities
write a DAO
add repositories
create a ViewModel
build forms in Compose
wire up navigation

It felt like I was writing scaffolding for days before I could even see my idea in action.

My attempt at solving this

That’s why I started working on a framework I call Compose Entity.
The concept is simple:

you define an entity,

and everything else — the SQLite table, DAO, repository, default form and navigation — is generated for you.

You can still customize forms with your own Composables if you want, but you don’t have to.

Example

@CeEntity(tableName = "person")
@CeGenerator(type = GeneratorType.Reference, generationLevel = GenerationLevel.UI,
    hasDetails = true, detailsEntityClass = DetailsPersonInfo::class)
@CeCreateTable(tableName = "person")
data class RefPersones(
    override var id: Long,
    override var date: Long,
    override var name: String,
    override var isMarkedForDeletion: Boolean,
    @CeField(type = FieldTypeHelper.NUMBER, label = "Age", placeHolder = "Select Age")
    var age:Int,
    @CeField(related = true, relatedEntityClass = RefGroupes::class, type = FieldTypeHelper.SELECT, extName = "groupe",
        label = "Groupe", placeHolder = "Select Groupe of the person")
    var groupeId: Long
): CommonReferenceEntity(id, date, name, isMarkedForDeletion){
    override fun toString(): String {
        return "$id: $name"
    }
}

From just this definition, I immediately get a database table, DAO, repository, and a working UI form for add/edit/delete.

Migrations

This part was important to me.
In systems like Room, migrations can feel unpredictable.
So Compose Entity works like this:

new tables are created automatically,
changes to existing tables (adding/removing fields) require you to write your own ALTER TABLE.
It may sound like less automation, but the benefit is:

no surprises,
full control over how data evolves,
compile-time checks that entities always match the DB schema.

Why I’m sharing this

For me, this cuts down boilerplate by ~90%.
I can test an idea in minutes, not days.
It feels much closer to the workflow I loved in Oracle, SAP, and 1C.

I’m sharing it here because I want to hear feedback:

Do you think this approach makes sense?

Would you find it useful in your Android projects?

Or do you prefer writing everything manually for maximum control?

Create Android project with yours name and packaje: https://cetempl.homeclub.top/
Full example of Compose Entity based app: https://github.com/SergeyBoboshko/CePowerPaymentBook

Watch this short video about how it works

Building SQLite Apps Faster with Jetpack Compose and Compose Entity

Serhii Boboshko — Mon, 18 Aug 2025 19:58:50 +0000

Building SQLite Apps Faster with Jetpack Compose and Compose Entity

Working with persistent storage in Android often follows the same routine:

Define SQLite tables.
Add DAOs, repositories, and ViewModels.
Build UI forms manually.
Manage migrations over time.

This approach is repetitive and time-consuming.

The Usual Workflow (Room + Compose)

A standard setup usually requires:

Declaring an Entity.
Writing a Dao.
Creating a Repository.
Implementing a ViewModel.
Designing Composables for forms.
Handling navigation and data persistence manually.

Every project starts here, and the boilerplate adds up quickly.

Compose Entity as an Alternative

Compose Entity provides a higher-level abstraction over Jetpack Compose and SQLite. Its main features include:

Automatic CRUD form generation.
Predefined repositories and ViewModels.
Automatic database migrations.
Support for extending generated forms with custom composables.

The result is that a working database + UI setup can be achieved by simply defining the data model.

Example: Defining an Entity

@CeEntity(tableName = "person")
@CeGenerator(
    type = GeneratorType.Reference,
    generationLevel = GenerationLevel.UI,
    hasDetails = true,
    detailsEntityClass = DetailsPersonInfo::class
)
@CeCreateTable(tableName = "person")
data class RefPersones(
    override var id: Long,
    override var date: Long,
    override var name: String,
    override var isMarkedForDeletion: Boolean,
    @CeField(
        type = FieldTypeHelper.NUMBER,
        label = "Age",
        placeHolder = "Select Age"
    )
    var age: Int,
    @CeField(
        related = true,
        relatedEntityClass = RefGroupes::class,
        type = FieldTypeHelper.SELECT,
        extName = "groupe",
        label = "Groupe",
        placeHolder = "Select Groupe of the person"
    )
    var groupeId: Long
) : CommonReferenceEntity(id, date, name, isMarkedForDeletion) {
    override fun toString(): String {
        return "$id: $name"
    }
}

Compose Entity will then:

Generate the underlying SQLite table.
Create a DAO and repository.
Provide a default form for adding, editing, and deleting records.

Database Migrations

Schema evolution is one of the most error-prone parts of working with Room. Compose Entity handles this automatically:

Adding fields → generates ALTER TABLE statements.
Removing fields → creates a safe copy, transfers the data, and rebuilds the table.
Strict version checks prevent silent data corruption.
All migrations are tracked in structured history for reliability.

This removes much of the manual work in keeping a schema aligned with your entities.

UI Extensibility

Auto-generated forms provide a functional default, but they are not restrictive. Developers can:

Inject custom composables into generated screens.
Combine automatic layouts with custom UI when more control is needed.

This makes it possible to balance rapid development with project-specific design.

Key Benefits

Boilerplate reduction of up to 90 percent.
Projects can be prototyped in minutes.
Suitable for quick experiments, internal tools, and production use.

Getting Started

To generate a project with Compose Entity, visit:
https://cetempl.homeclub.top/

You can download a ready-made Android Studio project with your chosen package name and application name. It is fully configured and ready to run.

The main page also includes a manual and several examples to explore.

https://youtu.be/KY_wtlVK8BE