Android and Backend Developer
The programme prepares future developers to build complete Android applications, from user-friendly interfaces to reliable backend services. Through practical projects, students develop skills in Kotlin, mobile development and connecting apps to the systems behind them.
Education overview
Companies need developers who can build and maintain Android apps and understand the services behind them. The programme combines mobile interfaces, data handling, testing and team workflows with planned backend development, so graduates can follow a feature from the app to its API and database.
Relevant roles
Junior Android developer and mobile app developer, with introductory backend skills for teams working across app and server code.
Learning outcomes
- Build multi-screen Android apps with Kotlin and Jetpack Compose, managing navigation, state and lifecycle changes.
- Connect apps to REST APIs and local storage, handling asynchronous work, network errors and offline situations.
- Build a small Kotlin backend with Ktor and use SQL and Supabase to store and query relational data.
- Implement user registration and sign-in with Firebase Authentication and work with cloud documents in Firebase Firestore.
- Package a backend with Docker, deploy it on Railway and connect it to a working app.
- Apply Compose skills to a small desktop or web interface using the selected course tooling.
- Test and debug features, apply accessibility and security practices, and collaborate through Git, GitHub and code review.
Core technologies
Kotlin · Jetpack Compose · Ktor · SQL · Firebase
Expected level of independence
Graduates should be able to implement, test and explain a scoped app feature or a simple app-to-backend flow with code review and guidance. Backend, cloud deployment and cross-platform interfaces are introductory skills, not specialist-level responsibility for production infrastructure.
Curriculum and structure
Kotlin and programming fundamentals
Main content
Variables, types, control flow, functions, collections, null safety and object-oriented programming. Structured problem-solving and debugging with Android Studio and IntelliJ IDEA.
Learning outcomes
- Break a problem into smaller steps and implement a clear Kotlin solution.
- Use functions, classes and collections to organise reusable code.
- Read existing code and use the debugger to investigate errors.
Android, Jetpack Compose and user interfaces
Main content
Android project structure, activities, fragments, lifecycle, navigation and application state. Jetpack Compose layouts, interaction and design handoff with Zeplin. Planned introduction to Compose interfaces for desktop and web, according to the tooling selected for the programme.
Learning outcomes
- Build a multi-screen Android app with predictable navigation and state handling.
- Translate a design specification into an interface that adapts to different screen sizes.
- Handle lifecycle changes without losing relevant user state.
- Adapt a small Compose interface for desktop or web and explain platform-specific limitations.
App architecture, local storage and cloud databases
Main content
Separation of UI, application logic and data access; local persistence and asynchronous data flows. Planned extension into relational modelling, SQL and PostgreSQL through Supabase, plus document storage with Firebase Firestore.
Learning outcomes
- Separate interface code from data access and application logic.
- Persist local data and update the UI without blocking interaction.
- Model related records and write SQL queries to create, retrieve, update and delete application data.
- Use Supabase and Firestore in practical exercises and explain relational and document database trade-offs.
REST APIs and backend development with Ktor
Main content
HTTP methods, routes, status codes, JSON and asynchronous networking. Planned server-side Kotlin development with Ktor: request validation, API endpoints, database access and error handling. The backend scope draws on the web server, database and API topics in Web Server Programming 1 and 2 referenced in the expansion proposal.
Learning outcomes
- Consume an external REST API and handle loading, failure and unavailable network connections.
- Build Ktor endpoints that validate input and return appropriate responses.
- Connect a backend endpoint to stored data and an Android client.
- Explain the responsibilities of the frontend, backend and database in a complete request flow.
Testing, authentication and security
Main content
Unit and UI tests, debugging and maintainable code. Planned account registration and sign-in with Firebase Authentication, verification of identity in backend requests, access control, input validation and secure configuration.
Learning outcomes
- Write tests for important app behaviours and backend responses.
- Implement registration and sign-in, and distinguish authentication from authorisation.
- Check identity and access before returning protected user data.
- Investigate defects and keep secrets out of source control and app code.
Agile teamwork, Git and GitHub
Main content
Version control, branches, pull requests, issue tracking and code review. Iterative development, reading existing code and communicating progress, blockers and technical decisions.
Learning outcomes
- Break a feature into small tasks and track progress in a shared repository.
- Use Git branches and GitHub pull requests to review and integrate changes.
- Explain a change, respond to feedback and collaborate on an existing codebase.
Accessibility, publishing and backend deployment
Main content
Accessible interaction, assistive technologies and Android release checks. Planned Docker fundamentals for packaging a backend and Railway deployment, including environment configuration, service logs and basic troubleshooting.
Learning outcomes
- Check an interface for accessibility barriers and improve important user journeys.
- Prepare an Android release with documented quality checks.
- Build and run a basic Docker container, deploy a backend on Railway and check that the app can reach it.
Integrated final project
Main content
Develop an end-to-end solution around a defined user need: an Android interface, user accounts, cloud data, a REST API and a deployed backend. Document the architecture, tests and operating instructions for a demonstrable portfolio project.
Learning outcomes
- Deliver and demonstrate a working app connected to authenticated backend services.
- Show evidence of testing and explain data handling, architecture and usability decisions.
- Present the solution, its limitations and the improvements suggested by feedback.
Work-based learning (LIA)
Main content
Apply Android development and relevant app-to-backend skills in supervised workplace tasks with agreed learning goals.
Learning outcomes
- Contribute a scoped app feature, fix or test within an existing development team.
- Use the team’s tools and workflows, document work and act on professional feedback.
Entry requirements and target audience
Beginners and career changers who want to develop Android apps and understand how mobile interfaces connect to server-side services. The programme suits people interested in practical problem-solving and collaborative software development.
Entry requirements
- English sufficient to follow teaching, read technical documentation and explain your work.
- High school mathematics, including basic algebra and logical reasoning.
- No previous programming or Android development experience is required.
Expected starting knowledge
Students start with Kotlin fundamentals before moving to Android and backend development. They need basic computer skills. They should be ready to practise regularly, solve problems and work with feedback.
How students apply their knowledge
Teaching and study format
Instructor-led online teaching, live coding, guided exercises and individual and team projects. Students progress from small Kotlin programs to Android apps and integrated app-and-backend solutions. GitHub submissions and code reviews make their reasoning and progress visible.
How learning is demonstrated
- Demonstrate app navigation, state changes, local persistence and network error handling.
- Show an authenticated app-to-API-to-database flow and explain how access to user data is controlled.
- Run automated tests and use debugging tools to identify and resolve faults.
- Deploy a backend and document how to run, configure and test the solution.
- Present code through GitHub, respond to review feedback and explain design choices and limitations.
Would you like to endorse this education?
Do these skills match what your company needs? Your perspective helps us make the education relevant to real work.
You are not required to
- Teach or prepare course materials.
- Hire students.
- Host interns.
- Attend recurring meetings.
How you can support us
- Share your current and anticipated skills needs.
- Give brief feedback on the curriculum and learning outcomes.
- Endorse the education’s relevance based on your own assessment.
Providing your initial feedback takes no more than 1 hour.
Give feedback and endorse this education