Key takeaways
- Everything in Flutter is a widget; know stateless versus stateful widgets and the State lifecycle by heart.
- The layout rule "constraints go down, sizes go up, parent sets the position" explains most overflow errors.
- Dart null safety (
?,??,!,late) and async code (Future, Stream, async/await) come up in almost every interview. - The last page lists ten most asked practice questions and a portfolio tip. These are original Uncodemy notes, not official Flutter documentation.
About these Flutter notes
This page offers Uncodemy's Flutter notes as a free handwritten-style PDF. Flutter is Google's open source UI toolkit that builds apps for Android, iOS, web and desktop from one Dart codebase, and it draws its own UI with its own rendering engine so the app looks the same on every device. The notes are written in short points with comparison tables, small code examples and REMEMBER and TIP boxes, so you can revise the whole framework in one sitting before a test, a project review or an interview.
Please note: these are original Uncodemy revision notes for beginners. They are not official Flutter or Google documentation, and package APIs change between versions, so check the official docs for the Flutter version you use.
What's inside the Flutter notes
The PDF has 8 pages arranged in 9 topic sections plus a final list of most asked practice questions. The order follows how most beginners learn Flutter: setup and Dart first, then widgets and layouts, then data, state and release. Here is what each section covers.
Flutter basics and setup
What Flutter is, its three layers (framework, engine and embedder), hot reload versus hot restart, flutter doctor, flutter create and flutter run, and a table of the main project files and folders such as lib/main.dart, pubspec.yaml, test/ and assets/.
Dart language basics
var, final, const and dynamic, lists, sets and maps with their common methods, string interpolation, the null safety operators, optional positional and named parameters, arrow functions and control flow, including collection if and for.
Dart OOP and async
Classes, short and named constructors, a table of extends, implements, with, enum, static and factory, private members and getters, Future versus Stream, async/await with an example, and isolates for heavy work.
Stateless and stateful widgets
The widget tree, a comparison table of StatelessWidget and StatefulWidget, a counter example with setState, the State lifecycle from createState to dispose, the MaterialApp and Scaffold skeleton, BuildContext, const constructors and keys.
Layout widgets
A table of Container, Row, Column, Stack, Expanded, Padding, ListView, GridView, Wrap, Card and more, main axis and cross axis alignment, the constraints rule, how to fix a RenderFlex overflow, and MediaQuery and LayoutBuilder for responsive screens.
Common widgets and theming
Text, Image, Icon and the button widgets, TextField with a controller, Form validation with a GlobalKey, dialogs, SnackBar and bottom sheets, Material 3 theming with light and dark themes, Cupertino widgets and gestures.
Navigation and state management
Navigator.push and pop, named routes and the go_router package, passing and returning data, bottom navigation, a table that compares setState, InheritedWidget, Provider, Riverpod, Bloc/Cubit and GetX, and the Provider flow step by step.
Networking, storage and Firebase
Calling an API with the http package or Dio, FutureBuilder and StreamBuilder states, fromJson and toJson model classes, a table of storage options (shared_preferences, sqflite, Hive, secure storage), Firebase services, plugins and platform channels.
Testing, build and release
Debug, profile and release modes, unit, widget and integration tests, DevTools and performance tips, a table of flutter build commands for APK, app bundle, iOS and web, Android signing, and good project habits.
Most asked questions (practice)
Ten interview-style questions, from Flutter architecture and hot reload to state management, API calls and publishing to the Play Store, plus a tip on the three portfolio apps worth building.
How to use handwritten notes to revise Flutter
Flutter is learnt by building, so keep the notes next to your editor: read a section, type its example, then change it until you understand what each line does.
- Recreate the counter app from the widgets section and add a reset button, so
setStateand the lifecycle stop feeling abstract. - Build one screen using only Row, Column, Expanded and ListView, then shrink the window to trigger and fix a RenderFlex overflow.
- Write the Provider flow from memory: ChangeNotifier,
notifyListeners, ChangeNotifierProvider,context.watchandcontext.read. - Call a free public API, show the result in a
ListView.builderwith loading and error states, and convert the JSON into a model class.
A simple three-pass method works well with these notes. In the first pass, read one section and underline only what is new to you. In the second pass, close the notes and write the terms, rules and steps for that section on a blank sheet, then compare and correct in a different colour. In the third pass, a day or two later, answer two or three of the practice questions aloud, as you would in an interview, using only memory. Add your own examples and doubts in the margins so the PDF becomes your personal revision copy.
Commands, widgets and rules to memorise
flutter doctor,flutter create,flutter run,flutter pub add,flutter testandflutter build apk,appbundle,iosandweb.final(set once at runtime) versusconst(compile time), and the null safety operators?.,??,!andlate.- The State lifecycle order: createState, initState, didChangeDependencies, build, didUpdateWidget, deactivate, dispose.
- "Constraints go down, sizes go up, parent sets the position", and that yellow and black stripes mean a RenderFlex overflow.
- When to use setState, Provider or Bloc, and FutureBuilder (one value) versus StreamBuilder (many values).
Common mistakes beginners make in Flutter
- Forgetting to dispose TextEditingController, animation controllers and stream subscriptions in
dispose(). - Putting a ListView inside a Column without Expanded or
shrinkWrap, which gives an unbounded height error. - Keeping data that many screens need in
setStateinstead of moving it to Provider or another state solution. - Skipping const constructors and building long lists with a plain ListView instead of
ListView.builder. - Adding images and fonts to the assets folder but not declaring them in
pubspec.yaml, so they fail to load.
Interview focus: Flutter topics asked most often
In fresher Flutter interviews and college project vivas, most questions come from widgets, Dart basics and state management, followed by API handling and app release.
- Stateless versus stateful widgets and the State lifecycle.
- Dart null safety,
finalversusconst, and Future versus Stream. - Layout widgets, the constraints rule and responsive screens.
- State management choices and how Provider works.
Typical long questions
- What is Flutter? Explain its architecture and why it uses Dart.
- Differentiate hot reload and hot restart, and stateless and stateful widgets.
- Explain the StatefulWidget lifecycle with the order of its methods.
- Explain Row, Column, Stack, Expanded and ListView.builder with a small example.
- Compare setState, Provider and Bloc and say when you would use each.
- How do you call a REST API and show the data in a list?
- List the steps to build and publish an Android app on Google Play.
Interview patterns differ between companies, so also practise explaining the code of your own project. In long answers, start with a one-line definition, add a small code snippet or a widget tree sketch, explain the steps and finish with a real use case from an app you built.
A 7-day revision plan for Flutter
- Day 1: Flutter basics and setup, Dart language basics.
- Day 2: Dart OOP and async.
- Day 3: Stateless and stateful widgets, Layout widgets.
- Day 4: Common widgets and theming, Navigation and state management.
- Day 5: Networking, storage and Firebase, Testing, build and release.
- Day 6: build a small to-do app with local storage that uses a form, a list and Provider.
- Day 7: answer the ten practice questions from memory, then add an API screen to your app and push the code to GitHub with screenshots.
Keep one sheet of commands, lifecycle methods and widget names from the notes for quick revision before an interview, and spend the last day polishing one app rather than starting new topics.
Who these notes are for
- BCA, MCA and B.Tech students building their first mobile app or a semester project in Flutter.
- Freshers preparing for Flutter or mobile app developer interviews.
- Web and Android developers who want a short summary of Dart and Flutter widgets.
- Students who finished a Flutter video course and want a compact revision sheet.
The notes are a revision aid, not a first course. If a Flutter topic is new to you, learn it from the official Flutter documentation or your class first, then use the notes to compress and revise it. For practice, build the three portfolio apps suggested on the last page: a to-do app with local storage, a weather or news app with an API, and an app with Firebase login. If you need notes on a topic that is not covered here, ask for it through the handwritten notes request page linked below.
Download Flutter Notes PDF
Flutter Notes PDF: Dart, Widgets and State
The PDF carries the same content as this page in a clean, print-ready layout, so you can read it offline and keep it for revision.
8 pages · 103 KB · PDF · Updated 5 Nov 2026