Cross-platform app developer (Flutter) roadmap

Dart has types like int, double, String and bool. Use final for a value set once and const for a value known before the app runs. Choosing final by default makes code safer and easier to read.

if/else and switch choose what to do, and for and while loops repeat work. Functions take inputs, do one job and return a result. Arrow functions (=>) are a short form you will see everywhere in Flutter code.

Null means "no value". In Dart a type with a question mark, like String?, may be null, and the compiler makes you handle it. Learn ?., ?? and when (rarely) to use !.

A class describes a thing, like a Product with a name and a price. Learn constructors, named parameters (very common in Flutter), and the required keyword. Learn the basics of inheritance, because every widget extends another class.

A List holds items in order and a Map stores values by key, much like JSON. Practise where, map, fold and sort on lists. You will use these to show, filter and total data on screen.

A Future is a value that will arrive later, like the response from a server. async and await let you write this waiting code top to bottom. A Stream gives many values over time, like live chat messages.

Git records your changes as commits so you can go back when something breaks. GitHub stores your projects online. Push every practice project with a short README.

Install the Flutter SDK, run flutter doctor and fix what it reports. Run your first app on an emulator and on a real phone. Learn hot reload, which shows code changes in under a second.

Text, Image, Icon and ElevatedButton are widgets, and you build screens by putting widgets inside other widgets. This is called the widget tree. Small, well-named widgets make your code easy to read.

A StatelessWidget never changes after it is built, like a title. A StatefulWidget keeps state, like a counter, and calls setState to redraw. Learn this well before moving to bigger state tools.

Column stacks widgets top to bottom, Row places them side by side, and Stack layers them. Padding, SizedBox, Expanded and Flexible control space. When you see a yellow and black overflow stripe, the content is too big for its box.

ListView.builder and GridView.builder build only the items that are on screen, so long lists stay smooth. Use a Card or ListTile for each row. Add pull-to-refresh with RefreshIndicator.

Material widgets follow Google's design system, and Cupertino widgets look like iOS. Set a ThemeData once with your colours and fonts. Support dark mode from the start.

Use TextField or TextFormField inside a Form, with a validator for each field. Show a clear message when the phone number or email is wrong. Choose the right keyboard type, like number for amounts.

MediaQuery and LayoutBuilder tell you how much space you have. Show one column on a phone and two on a tablet. Test on a small 5-inch phone, because many users have one.

When many screens share data, like a cart or the logged-in user, setState is not enough. Provider is simple, Riverpod is a popular modern choice, and Bloc is common in large companies. Learn one well first, and understand the idea behind the others.

Navigator.push opens a new screen and pop goes back. For bigger apps, the go_router package gives named routes and web-style addresses like /product/42. Learn to pass data between screens and return a result.

The http or dio package sends requests to a REST API. Always show a loading state, an error message and a retry button. Handle no internet and slow networks, which are common on mobile data.

jsonDecode turns JSON text into maps, and you then build Dart model classes with fromJson and toJson. For bigger apps, packages like json_serializable or freezed write this code for you. Typed models catch mistakes early.

shared_preferences stores small settings like the theme or language. For real lists of data, use a local database such as sqflite, Drift or Hive. Store tokens in secure storage, not in plain settings.

Separate UI, state and data: widgets show data, state classes hold logic, and repositories fetch or save data. Many teams organise folders by feature, like auth, cart and profile. Keep widgets free of network code.

pub.dev hosts thousands of Dart and Flutter packages. Check likes, pub points, last update and supported platforms before adding one. Fewer, well-maintained packages are better than many small ones.

The FlutterFire CLI connects your Flutter app to a Firebase project for Android and iOS. After setup you add only the Firebase packages you need. Keep separate Firebase projects for testing and for the live app.

Firebase Authentication handles phone OTP, Google and email login. Cloud Firestore stores data as documents and can send live updates. Write security rules so each user can only read and change their own data.

Firebase Cloud Messaging sends notifications to Android and iOS. Ask for permission politely and only when it makes sense. Crashlytics shows real crashes with the line of code, so fix the most common ones first.

Unit tests check plain Dart logic, like a price calculator. Widget tests build a widget, tap it and check what is shown. Use fake repositories so tests run fast without the internet.

Integration tests run the full app on a device or emulator and go through real flows, like login and checkout. They are slower, so keep them for the most important paths. Run them before every release.

Set the app name, icon and version, then build a signed app bundle with flutter build appbundle. Upload it in Google Play Console, which needs a one-time registration fee. Use internal or closed testing first, and check the current rules for new developer accounts.

iOS builds need a Mac with Xcode and a paid Apple Developer Program membership. You upload the build to App Store Connect, test it with TestFlight and send it for review. Read the App Store Review Guidelines before you submit, because rejections are common.

A platform channel lets Dart code call Kotlin on Android and Swift on iOS, for example to use a special SDK. Data passes as simple messages both ways. Learn enough Kotlin and Swift to write small native pieces, or to build your own plugin.

Flutter DevTools shows slow frames, memory use and how often widgets rebuild. Use const widgets, avoid rebuilding big parts of the tree and move heavy work off the main isolate. Always test in profile mode on a real, cheap phone.

An isolate is a separate worker with its own memory, so heavy tasks like parsing a huge JSON file do not block the UI. Isolate.run or compute makes this simple. Use it only when you have measured a real problem.

Measure app size and remove unused packages and large images. Use app bundles so each phone downloads only what it needs. Show the first screen quickly and load the rest later.

Split code into presentation, domain and data layers, and keep each feature in its own folder or package. Use dependency injection so parts can be swapped in tests. Write down the rules so new team members follow them.

Flavors let you build dev and production versions with different settings and Firebase projects. Run analysis, tests and builds on every pull request with GitHub Actions. Use staged rollouts so a bad release reaches only a few users first.

Never put secret keys inside the app, use HTTPS, and keep tokens in secure storage. Add semantic labels so screen readers can read your buttons, and support large text sizes. Add Hindi and other languages with Flutter's localisation tools.