1. Cross-Platform Responsiveness

Flutter’s versatility across mobile, web, and desktop platforms makes it a fantastic choice for modern app development. For responsive design, we can leverage techniques like MediaQuery and AspectRatio, or create our own Screen Utility (like the one I built: Reference code). While there are great packages out there, like flutter_screenutil, I’m a firm believer in the DIY approach — why outsource when you can keep it in-house? Of course, platform-specific configurations and theme-based implementations can also be easily integrated for a seamless, consistent user experience. Reference code. After all, building custom solutions is half the fun in coding!

2. Secure Frontend-Backend Communication

Use https for all network call with help of alice [ https://github.com/jhomlala/alice ] you can verify each screen APIs. For more securing use JWT or refresh token method. For offline sensitive information store use flutter_secure_storage [Ref: https://pub.dev/packages/flutter_secure_storage ]. Please find below diagram for more:

3. Flexibility for Future Enhancements

The BLoC pattern is a powerhouse for handling complex logic, which is why we’ve implemented it extensively. In one of my projects, we used a layered architecture — Presentation, Domain, and Data — inspired by Uncle Bob’s Clean Architecture. For example, in the Reward Module, RewardBloc manages all the reward-related logic, processing events like EarnPoints and RedeemReward to ensure smooth user interactions. The beauty of this approach? Adding new modules, like a Transaction or Chat module, follows the same principle, making future enhancements almost effortless. The key is flexibility — entities act as the bridge between the domain and repository, ensuring they speak the same language. Think of it like building a LEGO set: once you have the foundation, adding new pieces is a breeze!

4.Scalable Database Design

Our app is built to handle up to 100,000 users, so naturally, we opted for GraphQL — the cool middleman between the frontend and databases. Why GraphQL, you ask? Simple: it’s like ordering a combo meal instead of separate dishes. With just one API call, it fetches all the data you need, even if you’ve got a bunch of entity tables, minimizing those tedious round trips to the server.

Pairing GraphQL with the BLoC pattern is like getting the best of both worlds. We define resolvers in GraphQL to handle the database, while BLoC centralizes all the app’s business logic. And because we’re talking about 100,000 users, security’s tight — JWT secures our queries and mutations, with rate limiting for good measure. As for deployment? We’ve got versioning, feature toggles, and phased rollouts to keep everything smooth. It’s like launching a spaceship but with fewer explosions!

5.Separation of Business and View Logic

Every good app deserves a clear separation between business logic and view logic — after all, you wouldn’t want the brains of the operation tangled up in the presentation, right? That’s where BLoC and Provider come in. We chose this combo because it handles complex logic like a pro and keeps things scalable. With BLoC, the business logic stays neatly tucked away, completely independent of the UI. This way, when the app scales (and it will), we can make changes to the logic without touching the interface. It’s like having a personal chef: they handle the cooking, while you just enjoy the meal!

6.Deployment Strategy

Feature flags are like secret switches hidden in your app’s code — flick them on or off, and voilà! Features appear or disappear. In my case, I rolled out a reward system for just 5% of users using a simple JSON config file or Firebase Remote Config. It’s kind of like giving VIP access to a select few while the rest of the crowd waits at the gates.

Here’s the beauty of it: let’s say we’ve got a limited number of coupon codes. We launch to 5% of users, filtering by user ID or some unique identifier. Once those codes are gobbled up, we simply flip the feature flag switch, and boom! The reward system is down for maintenance (or as I like to call it, ‘coupon rehab’). If we need real-time updates, ably_flutter comes to the rescue with live events [Ref: https://pub.dev/packages/ably_flutter].

And when we push out a new version of GraphQL but the older app starts acting like a grumpy grandpa? No problem! Ably_flutter can clear local storage in real time, helping things run smoothly again. Plus, both Play Store and App Store have us covered with phased rollouts and Alpha/Beta testing. So, it’s all under control… most of the time!

And there you have it — building apps with scalable architecture, toggling features like a pro, and keeping everything under control (or at least pretending to!). Whether it’s handling reward rollouts for 5% of users or taming a grumpy old version of GraphQL, we’ve got the tools and techniques to make it happen.

If you’re itching to dive deeper and see all this in action, check out the seed repository I’ve put together: GitHub: dharmeshm10/seed. Just don’t forget to flip the right switches!

Thanks for sticking around till the end! If you have any questions, ideas, or just want to chat about all things Flutter and app architecture, feel free to connect with me on LinkedIn or catch me on Stack Overflow. I’d love to hear from you!

Until then, happy coding and remember — always flip the right switches!

What is Unit Test ?

• To test correctness of a logical unit.
• External dependencies mocked using Mockito

dependencies:
test: <version>
mockito: <version>

For better understanding we are taking example of Unit Test. Unit Test generally belong to flutter_test package.

import 'package:flutter_test/flutter_test.dart';

Suppose , there are class name counter and its having increment / decrement variable.

class Counter {
   int value = 0;
   void increment() => value++;
   void decrement() => value - ;
}

Now,

import 'package:flutter_test/flutter_test.dart';

void main() {

    group('Counter', () {
          test('value should start at 0', () {
          expect(Counter().value, 0);
     });

    test('value should be incremented', () {
         final counter = Counter();
         counter.increment();
         expect(counter.value, 1);
    });

    test('value should be decremented', () {
         final counter = Counter();
         counter.decrement();
         expect(counter.value, -1);
    });
  });
}

Above are simple summary of Unit Test, we can write with mock data as well, Let’s check example with mock data.

class Post {
  dynamic data;
  Post.fromJson(this.data);
}

Future<Post> fetchPost(http.Client client) async {
  final response = await client.get('<url>');

  if (response.statusCode == 200) {
    return Post.fromJson(
        json.decode(response.body)
    );
  } else {
    throw Exception('Failed to load post');
  }
}

We should divide to abstract class file for better structure. Now,

class MockClient extends Mock implements http.Client {}

Now test case,

group('fetchPost', () {

  test('returns a Post if the http call completes', () async {
    final client = MockClient();
    when(client.get('<url>')).thenAnswer((_) async =>
    http.Response('{"title": "Test"}', 200));

    expect(await fetchPost(client), const TypeMatcher<Post>());
  });

  test('throws an exception if the http call throws an error', () {
    final client = MockClient();
    when(client.get('<url>'))
        .thenAnswer((_) async => http.Response('Not Found', 404));
    expect(fetchPost(client), throwsException);
  });
}

What is Widget Test ?

Test a single widget

• To verify UI look.
• To check how it responds to actions

To add dependencies

flutter_test:
sdk: flutter

Let’s take an examples of widget

class WidgetTest extends StatelessWidget {
  final String title;
  final String message;
  const WidgetTest({Key key, @required this.title, @required this.message})
      : super(key: key);
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      home: Scaffold(
        appBar: AppBar(title: Text(title)),
        body: Center(child: Text(message)),
      ),
    );
  }
}

If you want to find widget then below terms are important.

Find

1. find.text
2. find.byWidget
3. find.byKey
4. find.byType

Action

enterText()

tester.enterText(find.byType(TextField), ‘hi’);

Tap()

tester.tap(find.byType(FloatingActionButton));

drag()

tester.drag(find.byType(Dismissible), Offset(500.0, 0.0));

How to rebuild?

pump(); & pumpAndSettle();

Now writing above widget test :

testWidgets('MyWidget has a title and message',
(WidgetTester tester) async {

await tester.pumpWidget(MyWidget(title: 'D', message: 'M'));


final titleFinder = find.text('D');
final messageFinder = find.text('M');


expect(titleFinder, findsOneWidget);
expect(messageFinder, findsOneWidget);



});

If there are action included then using pump() / pumpAndSettle() we can write

testWidgets('Add and remove a todo', 
(WidgetTester tester) async {
  await tester.pumpWidget(TodoList());
  await tester.enterText(find.byType(TextField), 'hi');
  await tester.tap(find.byType(FloatingActionButton));

  await tester.pump();

  expect(find.text('flutter'), findsOneWidget);
  await tester.drag(find.byKey(Dismissible), Offset(500.0, 0.0));

  await tester.pumpAndSettle();

  expect(find.text('flutter'), findsNothing);
});

What is Integrated Test ?

• For a larger part of application — important scenarios
• To test all widgets and services work together

For example,

A — Displaying Name

B — Edit Name

Suppose, you are editing your name on page B and you pop / get back to Page A then you must have UPDATED NAME Otherwise scenario is false.

So, There are more scenario we can cover but as per lager application.

— — — — Very Simple Example for covering all scenarios — — — —

Switch A is for Starting the Tube-light
So when Switch A is Enable You need to Test,

Positive: There is Light in Room.
Negative : There is No Dark in Room.

Only positive is not good need to cover negative too.

Happy coding!

With the use of MediaQuery, We can set screen size and height as per the given reference size.

Let’s code :

import 'package:flutter/material.dart';

class UIUtills {
  factory UIUtills() {
    return _singleton;
  }

  static final UIUtills _singleton = UIUtills._internal();

  UIUtills._internal() {
    print("Instance created UIUtills");
  }

//region Screen Size and Proportional according to device
  double _screenHeight;
  double _screenWidth;

  double get screenHeight => _screenHeight;

  double get screenWidth => _screenWidth;

  final double _refrenceScreenHeight = 640;
  final double _refrenceScreenWidth = 360;

  void updateScreenDimesion({double width, double height}) {
    _screenWidth = (width != null) ? width : _screenWidth;
    _screenHeight = (height != null) ? height : _screenHeight;
  }

  double getProportionalHeight({double height}) {
    if (_screenHeight == null) return height;
    return _screenHeight * height / _refrenceScreenHeight;
  }

  double getProportionalWidth({double width}) {
    if (_screenWidth == null) return width;
    var w = _screenWidth * width / _refrenceScreenWidth;

    return w.ceilToDouble();
  }

//endregion
//region TextStyle
  TextStyle getTextStyleRegular(
      {String fontName = 'Roboto-Regular',
      int fontsize = 12,
      Color color,
      bool isChangeAccordingToDeviceSize = true,
      double characterSpacing,
      double lineSpacing}) {
    double finalFontsize = fontsize.toDouble();

    if (isChangeAccordingToDeviceSize && this._screenWidth != null) {
      finalFontsize = (finalFontsize * _screenWidth) / _refrenceScreenWidth;
    }

    if (characterSpacing != null) {
      return TextStyle(
          fontSize: finalFontsize,
          fontFamily: fontName,
          color: color,
          letterSpacing: characterSpacing);
    } else if (lineSpacing != null) {
      return TextStyle(
          fontSize: finalFontsize,
          fontFamily: fontName,
          color: color,
          height: lineSpacing);
    }
    return TextStyle(
        fontSize: finalFontsize, fontFamily: fontName, color: color);
  }

}

if you have different base phone size just change _refrenceScreenHeight & _refrenceScreenWidth as per your requirements. Now use above utilities by following :

@override
Widget build(BuildContext context) {
  final screeSize = MediaQuery.of(context).size;
  UIUtills()
      .updateScreenDimesion(width: screeSize.width, height: screeSize.height);
}

After updating the screen dimension follow :

Padding(
  padding: EdgeInsets.only(
      left: UIUtills().getProportionalWidth(width: 32.0)),
  child: Text(
    'Home',
    textAlign: TextAlign.left,
    style: UIUtills().getTextStyleRegular(
        color: Color(0xFFFFFFFF), fontName:"Roboto-Medium", fontsize: 20),
  ),
)

Happy coding!