Compose interface with state
Deliverable: A multi-screen Compose application with hoisted state and navigation, proven to retain state across rotation and simulated process death.
Course
Android Development
Native Android in Kotlin and Jetpack Compose, with the lifecycle and configuration-change problems taught head-on because they are what actually breaks Android apps.
- Duration: 5 months
- Classroom · Online live
- Level: intermediate
What you will be able to do
- Write idiomatic Kotlin including null safety, data classes and coroutines
- Build interfaces with Jetpack Compose and reason about recomposition
- Survive configuration changes and process death without losing user state
- Apply a layered architecture with ViewModel and repository separation
- Persist data with Room and expose it reactively with Flow
- Consume REST APIs with Retrofit and handle failure properly
- Produce a signed release and take an app through Play Store submission
Who this course is for
- Graduates in engineering, computer applications or IT
- Java developers moving to Kotlin and mobile
- Anyone with programming fundamentals from any language
- Kotlin is taught from scratch; general programming logic is assumed
Syllabus
7 modules · 5 months
Module 1. Kotlin
- Types, null safety and the reason it exists
- Functions, default arguments and extension functions
- Data classes, sealed classes and when each fits
- Collections and functional operations
- Coroutines, suspend functions and structured concurrency
- Flow for streams of data
Module 2. Android fundamentals
- Activities, the lifecycle, and what actually triggers each callback
- Configuration changes and why rotation loses state
- Process death, and testing for it deliberately
- The manifest, permissions and the runtime permission flow
- Resources, densities and supporting many screen sizes
Module 3. Jetpack Compose
- Composables and the declarative model
- State hoisting and unidirectional data flow
- Recomposition, and why an app becomes slow
- Layout, modifiers and theming with Material 3
- Lists, lazy loading and keys
- Navigation in Compose
Module 4. Architecture
- Why architecture matters more on mobile than beginners expect
- ViewModel and surviving configuration change correctly
- Repository pattern and separating data sources
- Dependency injection with Hilt
- Single source of truth and unidirectional data flow
Module 5. Data
- Room entities, DAOs and migrations
- Exposing data as Flow for reactive interfaces
- Retrofit, serialisation and error handling
- Caching and offline-first behaviour
- DataStore for preferences
Module 6. Platform features and quality
- Background work with WorkManager
- Notifications and the current permission requirements
- Camera, location and file access
- Accessibility — TalkBack, content descriptions and target size
- Unit and UI testing
Module 7. Release
- App icons, adaptive icons and store assets
- Build variants for staging and production
- Signing, App Bundles and Play App Signing
- Play Console submission, data safety declarations and review
- Crash reporting and monitoring after release
Tools and technologies you will use
- Kotlin
- Android Studio
- Jetpack Compose
- ViewModel, Navigation and Lifecycle
- Room
- Retrofit and OkHttp
- Coroutines and Flow
- Hilt
- Git and GitHub
- Google Play Console
Projects you will build
Architected app with Room
Deliverable: An application with ViewModel, repository and Room persistence, exposing data as Flow, with tests covering the repository layer.
API-backed offline-first app
Deliverable: An application consuming a REST API with local caching, working sensibly with no network connection, and explicit loading, empty and error states.
Signed Play Store release
Deliverable: A signed App Bundle with store assets, screenshots, listing text and a completed data safety declaration, plus a written note on the likely review queries.
Where this course can take you
- Android Developer
- Mobile Application Developer
- Kotlin Developer
- Freelance App Developer
- Software Engineer
Duration, modes and fees
- Duration
- 5 months
- Delivery modes
- Classroom · Online live
- Fees
- Share your details for the current fee
- Fees vary by batch and delivery mode. Share your details and an advisor will confirm the current fee.
Placement assistance
Every student gets placement assistance — that is what 100% placement assistance means. It is support for all, not a job for all. We do not promise a specific salary, a specific number of interviews, or placement at any named company, and you should be wary of anyone who does.
What is included
- A place in the monthly placement drive, held every third Saturday
- The readiness programme every second Saturday — mock interviews and preparation
- CV review against the specific roles you are targeting
- Portfolio review, so your project work is presented the way a reviewer will read it
- Access to the vacancy pool employers send directly to the Samyak network
- Guidance on which roles realistically fit your background and which do not
- A place in the next drive, with coaching, if you are not selected in this one
What is not included
- Any guarantee of a job, an interview, or a particular salary
- Placement at a named or partner company
- Applying to jobs on your behalf
- Support before you have completed the course and its project work
- Visa, relocation or overseas placement assistance
The lifecycle is the hard part
Every Android developer learns this the same way, usually painfully. You build a screen, it works, you rotate the device, and everything the user typed is gone.
That is not a bug you introduced. It is Android destroying and recreating your activity, and it is by design. The system can also kill your process entirely while the app is in the background and restore it later, into a state your code must be able to rebuild.
We teach this in module two, before Compose, and every project has a rotation and process-death requirement in its deliverable. It is the difference between an app that survives a real user and one that only survives a demo.
Compose first, XML enough to read
New Android work increasingly starts in Compose, so that is what we teach as primary — the declarative model, state hoisting, and why recomposition makes an app slow.
But a large amount of existing Android code is XML layouts, and a working developer will be asked to maintain it. So we cover enough XML to read a layout and modify it safely, without pretending it is where new work happens.
Architecture earns its keep faster on mobile
On a server you can restart a process. On mobile the system takes your process away without asking and expects you to come back gracefully.
That is why ViewModel, repository separation and a single source of truth matter more here than beginners expect. Without them, state lives in the UI layer and disappears exactly when the system decides to reclaim memory.
We introduce architecture in module four rather than at the end, because retrofitting it into three finished projects teaches the lesson the expensive way.
Publishing, properly
The fourth project is a signed App Bundle with store assets and a completed data safety declaration.
That last item catches people. Play Console now requires a detailed statement of what data your app collects and shares, and getting it wrong delays review. Having been through it once means the second time is routine — and “I have published to the Play Store” carries weight that “I built an app” does not.
Questions
Android Development — frequently asked questions
Should I learn native Android or Flutter?
Native Android if you are targeting companies with an established Android team, since those postings usually name Kotlin specifically and expect platform depth. Flutter if you want one codebase across both platforms, which suits startups, agencies and freelance work. Native gives deeper platform access; Flutter gives faster coverage.
Do I need to know Java first?
No. Kotlin is the current standard for Android and is taught here from scratch. Java experience transfers easily if you have it, but starting directly with Kotlin is the shorter path and matches what employers now expect. General programming comfort from any language is the real prerequisite.
Is Jetpack Compose replacing XML layouts?
Compose is the direction Google is taking Android, and new applications increasingly start with it. XML layouts remain in a large amount of existing code, so a working Android developer will meet both. This course teaches Compose as primary and covers enough XML to read and maintain existing screens.
Why does the course spend so long on the lifecycle?
Because it is the single most common source of Android bugs, and the one beginners consistently underestimate. Rotating the device recreates your activity. The system can kill your process and restore it later. An app that loses the user's input on rotation looks broken, and interviewers ask about it precisely because it separates people who have shipped from people who have followed tutorials.
Enquire about Android Development
Three details is all we need. A course advisor will call you back.
Related courses
- Flutter
One codebase for Android and iOS, taught through to store release — because the parts that defeat people are release signing and store review, not widgets.
- Java Programming
Core Java properly, then Spring Boot — with real weight given to object-oriented design and the collections framework, because that is what enterprise Java interviews actually test.
- Full Stack Java
The stack large Indian enterprises and services firms actually run — Java and Spring Boot on the server, React on the client, with a relational database designed properly underneath.
Next step
Talk to a course advisor
Tell us what you want to learn and we will help you pick the right course, batch and mode.