Stitch Counter (V2)

One product, two native stacks: Android shipped on Google Play production and an iOS SwiftUI rewrite in progress toward the same local-first experience.

Stitch Counter V2 solves a practical problem for knitters and crocheters: keeping long-running projects safe, readable, and easy to continue across sessions. I rebuilt the original Android app in Kotlin with Jetpack Compose, Room, and DataStore so it can handle real usage patterns and local backup and restore (zip, no cloud). I added CI/CD so regressions and releases stay predictable: CI on every PR, CD to Play internal—same setup I’d use on a team where release discipline matters. The iOS rewrite is in progress toward the same local-first experience.

Play installs

1k+ installs

Stability (Google Play Console)

0 crashes

Test signal · Code coverage

Stability figures come from Google Play Console; install count matches the Android README for this production release.

CI/CD status

Case studies (architecture, UI/UX, screenshots) for this app are below on this page.

Engineering snapshot

Kotlin app with Jetpack Compose + Material 3 across counter, library, settings, and project detail flows.
Room handles structured project and counter data; DataStore stores preferences and active theme state.
Six shipped themes with per-theme launcher icon updates and dark mode support.
Local backup and restore uses zip metadata + images, with typed failures and safe user messaging—no cloud sync.
CI runs on pull requests and pushes to main; CD publishes signed AABs to Play internal after successful CI on main.
Real performance details include debounced autosave and controlled list scrolling for large libraries.

Native Android · Shipped

KotlinJetpack ComposeMaterial3RoomHiltDataStoreCoilRamcosta Compose Destinations

Native iOS · In Progress

SwiftSwiftUISwiftDataCombinePhotosUIZIPFoundation

Get Stitch Counter on Google Play Privacy Policy EULA

View Android codebase on GitHub View iOS codebase on GitHub

Case studies

Feature development: Architecture, data, reliability

Selected work from this production app: data layer, backup/restore, and stable UI tied to real state.

Structured local dataData safety & portabilityLayered, maintainable code

How I structure feature work

Separation of concerns: UI, logic, and data stay apart.

Data as a stable foundation: Clear persistence; survives growth.

Reliability by design: Validates and fails safely, not only the happy path.

UI that follows real state: Clear loading states and errors; smooth lists.

Room DAO

Proof: One app, clear layers (UI, domain, data)

Stitch Counter V2 keeps screens thin and puts rules and persistence where they are easier to test and change.

Case study 1 · App architecture

How the app is wired

What it does

Compose and ViewModels on top; small use-case classes for validation and orchestration; Room underneath with Flow-backed queries so lists refresh when the database changes. This is MVVM-style: Compose + ViewModels over use cases and Room.

Why it is built this way

Hilt wires the DB, repository, and use cases once; feature code only pulls what it needs
Domain models and mappers sit between Room entities and the UI, so schema tweaks do not ripple through every screen
Deletes run through use cases that remove image files and rows together so files and rows stay in sync
Compose Destinations plus one root scaffold keeps tabs, rail, and sheets aligned on phones and tablets

What you get from it

Most changes stay in one layer. Reviews stay smaller, and you ship without re-threading the whole codebase.

Room → Flow → UI

Root navigation shell

Proof: Scalable data schema that won’t break as your app grows

Your data is structured, persistent, and built to scale; so your app stays reliable as features grow.

Case study 2 · Data architecture

Project management system

What it does

A structured system for creating, editing, and organizing projects with persistent local storage through Room.

What makes it valuable

Data is safely stored and persists across sessions (no loss, no resets)
Well structured relationships between features and data
Built to handle growth without performance issues
Clear separation of UI and logic for easier updates and fewer bugs

Why this matters for your app

Your app is built on a solid foundation, so it stays stable, scalable, and easy to expand over time. No rebuilds. No fragile code.

Project library

Project details

Room DAO

Proof: Keep user data safe and transferable across devices

Back up and restore app data locally without loss, so users can move to a new device and keep their progress.

Case study 3 · Data safety & reliability

Backup & restore system

What it does

Safely export and restore full app data with validation and error handling.

What makes it valuable

Data can be backed up and restored without corruption or loss
Invalid data is handled safely to prevent crashes
Clear feedback for success and failure states
Edge cases handled to keep behavior predictable

Why this matters for your app

Protects user data and prevents crashes, so your app stays reliable even when things go wrong.

Backup & restore UI

BackupManager

Proof: Fast, stable UI that stays in sync as your app grows

Keep scrolling, updates, and navigation smooth without lag, dropped frames, or out-of-sync state.

Case study 4 · Performance & state handling

Fast, stable UI and state handling that stays in sync

What it does

Keeps UI, navigation, and state updates fast and in sync across complex screens.

Performance and state handling in real usage

Smooth scrolling and interaction with large datasets
No UI freezing or dropped frames
UI stays in sync with navigation and app state
Efficient rendering that avoids unnecessary work and reduces battery usage

Why this matters for your app

Keeps your app fast and predictable, even as data and complexity grow, without lag or inconsistent behavior.

Smooth scrolling (LazyColumn)

UI in sync with navigation

Android UI/UX: Built for real devices

Fast, reliable feature work for existing Android apps. Interfaces and experience that hold up under real use.

Real app systemsResponsive UISmart UX

What I build

New features added to your existing Android app

Responsive Compose UI that works across devices

UX that increases user engagement

Clean, maintainable feature architecture (MVVM / separation of concerns)

Project library

Proof: Production-ready UI that works flawlessly across devices

Get instant, lag-free input and a layout that scales cleanly across phones and tablets: no broken screens, no performance issues.

Dynamic text scaling — portrait

Dynamic text scaling — landscape

Case study 1 · UI / interaction

Smart counter system

What it does

A real-time counter interaction system designed for fast input and long-running usage sessions.

What makes it valuable

Instant input response with no visible UI lag
UI that adapts cleanly as content changes (no overflow or layout breakage)
Seamless experience across portrait and landscape on phones and tablets
Consistent, stable layout across different screen sizes

Why this matters for your app

Designed to hold up under real usage, not just ideal conditions, so your app stays stable as users interact with it over time.

Proof: Consistent, polished UI across every screen and theme

Switch between themes and dark modes without visual bugs, broken layouts, or inconsistent styling.

Case study 2 · UI / UX

Dynamic theme system

What it does

A flexible theming system that supports multiple visual styles with consistent behavior across the entire app by overriding Material Design 3.

What makes it valuable

Multiple fully designed themes with consistent styling across all screens
Dark mode support for every theme
Custom app icons that match each theme for a cohesive experience
Centralized styling system that keeps UI consistent as features grow
Theme switching without layout issues

Why this matters for your app

Creates a polished, cohesive experience across your entire app, so it feels intentional and production-ready instead of pieced together.

Theme settings

Counter · dark

Counter · light

Library · Forest

Library · Sea

Proof: Intuitive interactions that stay fast and predictable as your app grows

Handle complex actions like editing, deleting, and navigation without confusion, lag, or clunky workflows.

Case study 3 · UI / UX

UI interaction & usability system

What it does

A set of interaction patterns and screen designs that handle complex user actions while keeping the app fast, clear, and easy to use.

Real interaction patterns used in the app

These patterns are used throughout the app and can be adapted to different features.

Swipe actions and multi-select for fast bulk delete operations
Bottom sheets for quick edits without leaving the current screen
Expandable UI that handles complex content without clutter
Structured detail screens for editing titles, notes, images, and progress
Clear visual feedback for user actions and state changes
Modal dialogs for important decisions or confirmations to prevent accidental actions and user errors

Why this matters for your app

Prevents confusing or clunky interactions, so users can move through your app quickly without friction as features and data grow.

Multi delete

Swipe to delete

Confirm delete

Project details

Expanding cards