Building an AAC App in 2026
Sesla's core development is complete: 10 phases, 610+ tests, a Turkish morphology engine, 3,400+ symbols, and a full communication experience — built by one developer with an AI pair programmer. Here's how.
610+
Tests
3,436
Symbols
10
Build Phases
16
Screenshot Tests
The Stack
Flutter was the only realistic choice for a solo developer targeting both iOS and Android. The Impeller rendering engine handles image-heavy symbol grids at near-native performance, which is critical when you're rendering 20-60 symbols per screen.
The rest of the stack: Drift for the SQLite database (type-safe queries, migrations, streams), Riverpod 3 for state management (the new Notifier pattern is excellent once you learn the gotchas), and GoRouter for declarative navigation.
All data stays on-device. No server, no cloud, no tracking. For an app used by children with disabilities, privacy isn't a feature, it's a requirement.
The Turkish Morphology Challenge
This is where it gets interesting. Turkish is an agglutinative language, meaning you build
words by stacking suffixes. "I am not going" in English is three words. In Turkish
it's one: gitmiyorum (git + mi +
yor + um).
For an AAC app, this matters a lot. When a child taps the symbol for "go" (gitmek), the app can't just speak the infinitive. It needs to conjugate: "Gidiyorum" (I'm going), "Gitmiyorum" (I'm not going), "Gittim" (I went). And the suffixes change based on vowel harmony. Turkish has strict rules about which vowels can follow which.
I built a rule-based morphology engine, not ML, because Turkish grammar is deterministic. The engine handles:
Verb conjugation: present continuous, simple past, future, and
imperative tenses across 6 persons, with negative forms. Plus special cases like
consonant softening (git → gid- before vowels) and vowel-stem
verbs (ye → yi-).
Noun declension: 6 grammatical cases (nominative, accusative, dative, locative, ablative, genitive) with 4-way and 2-way vowel harmony.
Auto-conjugation in the communication path: when speaking a sentence in Turkish, the app detects verb infinitives (words ending in -mak/-mek), looks up the stem in a verb dictionary, and conjugates to present continuous first person, the most common form in AAC usage for children.
Symbol System
Sesla uses Mulberry Symbols (CC BY-SA 4.0), the only high-quality, open-source symbol set suitable for commercial AAC use. I looked at ARASAAC too (excellent quality but CC BY-NC-SA, so no commercial use) and decided Mulberry was the right foundation.
3,436 symbols are bundled in the app as SVGs, organized into categories matching the Fitzgerald Key color system used in speech therapy. All symbols have Turkish translations — a major localization effort that goes beyond simple word mapping. Turkish doesn't just translate "eat" → "yemek" — cultural context matters. The symbol for "toast" in a Turkish AAC board should be "tost" (Turkish-style toast), not the American version.
Testing Philosophy
AAC apps are medical-adjacent software. A bug that shows the wrong symbol or speaks the wrong word isn't just annoying, it prevents a child from communicating. So testing is taken seriously:
610+ tests covering data layer integrity, TTS service behavior, morphology correctness (verb conjugation edge cases were brutal to get right), profile management invariants, board seeding, UI widget rendering, and a 334-case Turkish sentence grammar benchmark.
16 integration screenshot tests that capture real app journeys (onboarding, home screen, settings, search, profiles, dark mode, high contrast) on a simulator, then get visually verified. This catches layout breaks, missing translations, and rendering issues that unit tests can't.
AI-assisted code reviews after every major phase. An AI reviewer catches things you miss when you're deep in implementation: architecture issues, missing edge cases, constraint violations. Several critical bugs were caught this way before they could reach users.
How AI Fits Into the Workflow
I use AI as part of my development workflow, particularly for code reviews, generating test cases, catching edge cases, and validating that the implementation matches the design intent.
Think of it as having a tireless QA partner. After I finish a feature, I run it through AI review. It finds the constraint violation I overlooked, the null check I forgot, the test case I didn't think of. That feedback loop (build, review, fix, test) is where AI genuinely speeds things up for a solo developer.
AI helps me ship with fewer bugs. The domain knowledge, the product decisions, the code, that's still my job. AI just makes the review and testing cycle faster.
What's Next
The core is done. What remains is the last mile: app icons, store listings, beta testing with real families, and the things you can only learn from putting software in people's hands.
Phase 10 is launch. After that: more features based on what real users actually need. The roadmap exists, but the best ideas will come from watching families use the app.
Follow this devlog for updates. If you know a family that could benefit from Sesla, stay tuned. Beta is coming soon.