In May 2023, Google announced that Firebase Dynamic Links (FDL) would be deprecated with no replacement. As of today, the countdown is real: all existing FDL links will stop working on August 25, 2025: just over 100 days away.

This guide is for Flutter developers looking to migrate from Firebase Dynamic Links to other deep linking options, whether you need simple link routing or advanced features like deferred deep linking and install attribution.

What Are Dynamic Links (and Why Do They Matter)?

Dynamic links are essential for apps that care about:

• Seamless onboarding: Open to the right screen after install
• Marketing & attribution: Track installs from ads or QR codes
• Cross-platform consistency: One link that works on iOS, Android, and web
• In-app navigation: Route users to specific content via URLs

Typical Flow of a Dynamic Link

1. User taps a link (e.g. from email, ad, or QR code)
2. If the app is installed → it opens to the correct screen
   If not → user goes to the App Store / Play Store
3. After install, the app opens to the linked screen (if deferred linking is supported)

Post August 25, 2025: All Firebase Dynamic Links will stop working

• Web: Shows a 404 page
• Mobile SDKs: Return 400 errors

Why is Google Deprecating FDL?

Google hasn’t given a full reason, but the ecosystem is moving toward native deep linking standards:

• 🔗 App Links (Android)
• 🍎 Universal Links (iOS)

These are more privacy-safe, OS-supported, and less reliant on a third-party intermediary.

🛠️ Your Deep Linking Options (in Flutter)

Depending on your needs, you can go native or use a third-party SDK.

Need help migrating your app? reach out: happy to help!

Book a Free Consultation

Option A: Native Deep Links

App Links (Android) + Universal Links (iOS)
For simple, direct in-app routing. No analytics or deferred linking.

Setup in 3 Steps:

1. Host Digital Asset Files

• Android:
  URL: https://yourdomain.com/.well-known/assetlinks.json
• iOS:
  URL: https://yourdomain.com/.well-known/apple-app-site-association

2. Sample File for Android

jsonCopyEdit[
  {
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "com.example.app",
      "sha256_cert_fingerprints": ["YOUR_SHA256_HASH"]
    }
  }
]

3. Sample File for iOS

jsonCopyEdit{
  "applinks": {
    "apps": [],
    "details": [
      {
        "appID": "YOUR_TEAM_ID.com.example.app",
        "paths": [ "/promo/*" ]
      }
    ]
  }
}

4. Flutter Routing with go_router

dartCopyEditfinal router = GoRouter(
  routes: [
    GoRoute(
      path: '/',
      builder: (_, __) => HomeScreen(),
      routes: [
        GoRoute(
          path: 'promo',
          builder: (_, __) => PromoScreen(),
        ),
      ],
    ),
  ],
);

🚫 What You Don’t Get with Native Links:

• No deferred deep linking (new users won’t land on the right screen after install)
• No campaign tracking or attribution
• No short link generation

Option B: Use a Deep Linking SDK (for deferred linking + analytics)

These SDKs are your best bet if you need install tracking, deferred links, or marketing attribution.

🔁 Migrating from Firebase Dynamic Links

Step 1: Export Your FDLs

From the Firebase console, download all existing links via CSV.

Step 2: Choose the Right Path

Step 3: Update Your Flutter App

• Remove FDL SDKs & dependencies
• Add the new provider’s Flutter SDK
• Update link routing logic (e.g. using getInitialLink, go_router, or provider-specific handlers)
• Test on iOS & Android, with and without app pre-installed

Bonus: Real-World Example

Let’s say you’re running an event app:

• You want to send new users a link to a specific event
• If the app is installed → they open directly to the event
• If not → they go to the App Store, install, and still land on the right event

➡️ Use Branch.io or AppsFlyer, which support deferred deep linking, attribution, and short links.

Best Practices

• Use HTTPS and custom domains for all links
• Test fallback behavior (broken link ≠ broken UX)
• Track link performance in dashboards (especially during launch campaigns)
• Secure your asset files: they control your app’s linking permissions

📚 Resources & Links

• Firebase Dynamic Links FAQ (Official)
• Flutter Deep Linking Guide
• Branch Flutter SDK Docs
• AppsFlyer Flutter Guide
• Adjust Flutter SDK
• Kochava SDK Docs

⚠️ Final Reminder

All Firebase Dynamic Links will stop working on August 25, 2025.
Start migrating now to avoid broken user experiences, lost attribution data, and failed campaigns.

Need help migrating your app? reach out: happy to help!

Book a Free Consultation

The answer is a resounding yes. In fact, understanding Flutter’s layout system is more essential than ever. As we begin to integrate intelligent agents and model-driven UI states, a solid grasp of layout mechanics allows you to build UIs that are not just reactive—but adaptive, scalable, and emotionally resonant.

This guide covers responsive design techniques in Flutter and reframes them in the context of modern tooling like Bolt, agent UIs, and lovable app design.

Why Responsive Design Still Matters in 2025

Modern UIs need to adapt across not just screens—but also:

• Device contexts (foldables, desktops, ultra-wide monitors)
• Model states (MCPs triggering different UIs)
• AI-generated or agent-driven layouts

Even with AI composing parts of the UI, developers are still responsible for guiding layout structure, ensuring accessibility, and crafting delightful, context-aware interactions.

Responsive layouts remain the foundation for scalability, personalization, and seamless cross-device experience.

Core Flutter Layout Concepts

1. Widget-Based Layout System

Everything in Flutter is a widget—including layout structures. This composable model makes it easy to encapsulate and reuse layout logic.

2. Constraint-Based Rendering

Widgets receive layout constraints from their parent and size themselves accordingly. This model allows for granular control of layout behavior.

3. Foundational Widgets for Responsive UI

• Container: For spacing, alignment, and decoration.
• Row / Column: Horizontal and vertical layout control.
• Stack: For overlaying widgets, useful for layering elements.

Key Techniques for Responsive Design

1. Using Flexible and Expanded

Row(
  children: [
    Expanded(flex: 2, child: Container(color: Colors.red)),
    Expanded(flex: 1, child: Container(color: Colors.blue)),
  ],
)

Use Expanded when children should divide space proportionally. This is still valid, even when layouts are chosen by AI or agents.

2. LayoutBuilder: Layout Decisions Based on Space

LayoutBuilder(
  builder: (context, constraints) {
    return constraints.maxWidth > 600
        ? WideLayout()
        : NarrowLayout();
  },
)

Especially powerful when used with state-driven models (MCP) or agent responses.

3. MediaQuery: Get Device Info

final screenSize = MediaQuery.of(context).size;
if (screenSize.width > 800) {
  return LargeWidget();
} else {
  return SmallWidget();
}

Still critical when developing multi-device experiences and verifying AI-generated layout variations.

4. OrientationBuilder: Respond to Screen Rotation

OrientationBuilder(
  builder: (context, orientation) {
    return orientation == Orientation.portrait
        ? PortraitLayout()
        : LandscapeLayout();
  },
)

Essential for mobile-first and tablet-hybrid UIs.

5. AspectRatio: Maintain Proportions

AspectRatio(
  aspectRatio: 16 / 9,
  child: Container(color: Colors.green),
)

Ideal for video players or agent-driven visual modules.

Custom Grids and Staggered Layouts

Responsive GridView Example

GridView.count(
  crossAxisCount: MediaQuery.of(context).size.width > 600 ? 3 : 2,
  children: List.generate(9, (index) {
    return Center(child: Text('Item $index'));
  }),
)

Staggered Layout with flutter_staggered_grid_view

StaggeredGridView.countBuilder(
  crossAxisCount: 4,
  itemCount: 8,
  itemBuilder: (context, index) => Container(
    color: Colors.green,
    child: Center(child: CircleAvatar(child: Text('$index'))),
  ),
  staggeredTileBuilder: (index) => StaggeredTile.count(2, index.isEven ? 2 : 1),
)

Use cases include news feeds, dashboards, and AI-assembled interfaces.

Agent-Driven and Model-Adaptive Layouts

Adaptive Layouts with MCP or Agent State

class AdaptiveContainer extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(
      builder: (context, constraints) {
        final currentModel = context.watch<MyComposableModel>();
        return currentModel.isWideView
            ? WideContainer()
            : NarrowContainer();
      },
    );
  }
}

This is where agents and models meet responsive design.

AI + Developer: A Powerful Duo

AI agents can generate scaffolds or dynamic UIs, but as a developer:

• You ensure accessibility, responsiveness, and performance.
• You define constraints, breakpoints, and edge-case handling.
• You guide layout aesthetics to create lovable, human-first interfaces.

Bonus: Scalable Graphics with SVG

SVGs remain important for web UIs:

SvgPicture.asset(
  'assets/my_icon.svg',
  width: 50,
  height: 50,
)

Perfect for icon systems and resolution-independent visuals.

Closing Thoughts: Building Lovable, Scalable, Responsive UIs

Responsiveness in Flutter is no longer just about screen size—it’s about adaptability. Whether you’re reacting to user intent, device size, or AI-driven decisions, knowing the layout fundamentals enables you to build UIs that feel natural, elegant, and scalable across any context.

In the era of intelligent UI, the basics aren’t outdated—they’re superpowers.

This guide shows you how to manage multiple Flutter versions efficiently using FVM (Flutter Version Management) and Puro.

Why Use Multiple Flutter Versions?

• Legacy Support: Older projects might depend on specific versions.
• Testing: Ensure your app works across multiple Flutter releases.
• Experimentation: Try out beta/dev features without affecting production code.
• Team Alignment: Keep version consistency across team members and CI environments.

Option 1: FVM

FVM is an open-source tool built and maintained by the Flutter community. It simplifies version management by allowing per-project SDK configurations, speeding up channel switching, and reducing environment inconsistencies across teams.

View FVM on GitHub.

1. Install FVM

Install FVM globally on your system using Dart:

dart pub global activate fvm

Once installed, the fvm command will be available via your terminal.

2. Install Multiple Flutter Versions

You can install as many Flutter versions as you want:

fvm install 2.10.0
fvm install 3.0.0
fvm install stable
fvm install beta
  

This caches each version locally so switching is instant and offline-ready.

3. Use a Specific Flutter Version in a Project

Before setting the version, make sure you’re inside your project folder:

cd path/to/your/flutter_project
fvm use 3.0.0
  

This does two things:

• Creates a .fvm/ directory in your project.
• Creates a fvm_config.json file locking the project to that version locking the project to the specified version e.g., 3.0.0

4. Run Flutter Commands via FVM

To use Flutter CLI commands with the version set above:

fvm flutter pub get
fvm flutter run
fvm flutter build apk
  

This ensures you’re always using the correct version per project.

5. Switching Between Versions

To switch the Flutter SDK version for a project, simply run:

fvm use 2.10.0

You can switch versions at any time. FVM handles the linking.

6. List Installed Versions

See all installed Flutter versions on your machine:

fvm list

IDE Configurations

VSCode: Add this in .vscode/settings.json

{
   "dart.flutterSdkPath":".fvm/flutter_sdk",
   "search.exclude":{
      "/.fvm":true
   },
   "files.watcherExclude":{
      "/.fvm":true
   }
}

Xcode: In Build Phases → Run Script:

# Ensure Flutter SDK path is set for Xcode builds
export FLUTTER_ROOT="$PROJECT_DIR/../.fvm/flutter_sdk"
# Include path for Flutter tools (optional but recommended)
export PATH="$FLUTTER_ROOT/bin:$PATH"
# Call the Xcode build script provided by Flutter
"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh" build

Android Studio: Set Flutter SDK path to:

/absolute-project-path/.fvm/flutter_sdk

Optional: Add to .gitignore

It’s a good practice to ignore the FVM SDK path:

.fvm/flutter_sdk

Best Practices for Working with Multiple Versions

• CI/CD: Use fvm in your CI setup to ensure consistent versions across environments.
• Documentation: Mention the Flutter version used in your project’s README.md.
• Stay Updated: Periodically check for new versions and run fvm upgrade as needed.

Option 2: Puro – A Performant Alternative?

Puro is another powerful tool specifically designed for installing, managing, and upgrading Flutter versions. Its primary focus is on performance, aiming to make version management faster while using significantly less disk space and network bandwidth compared to traditional methods.

• Learn More: Puro Website, Puro on pub.dev

Key Features of Puro:

• Speed: Faster downloads and installations through parallel operations and intelligent caching.
• Efficiency: Reduced disk space and network usage via object deduplication and symlinking, especially beneficial when managing many versions.
• Environments: Uses a concept of named “environments” which can be tied to specific versions or channels (like stable, beta) and managed globally or per-project.
• Automatic IDE Configuration: Aims to configure IDE settings automatically when you switch environments.

How to install Puro on Windows, Linux, Mac?

FVM vs. Puro: Which to Choose?

• Choose FVM if:
  • You prefer a widely adopted, community-standard tool.
  • You are comfortable with the straightforward per-project configuration using .fvm.
  • Manual IDE setup is acceptable.
• Choose Puro if:
  • Performance (speed, disk space, network usage) is a major concern, especially if you manage many versions or have slower internet.
  • You like the concept of named “environments” for managing versions.
  • You prefer potentially automated IDE configuration.

Both are excellent tools solving the same core problem. You can even try both (though generally, stick to one per project for clarity).

How We Use AI to Manage Flutter at Scale

At Ambeego, we take an AI-first approach to building apps — not in a gimmicky or superficial way, but in ways that drive real, high-impact efficiencies where they matter most. Below are our top AI-powered strategies we recommend when operating at enterprise scale or managing a large user base:

1. AI Flutter SDK Upgrade Assistant

This AI agent reads Flutter changelogs, scans your codebase for deprecated APIs, and recommends migration steps.

It can even create a pull request with proposed changes and run tests to compare behaviors across versions. It saves dev time, reduces risk, and accelerates safe upgrades.

Enterprise impact:

• Speeds up upgrade cycles with confidence.
• Reduces risk of post-release issues.
• Saves dev time during quarterly/annual tech audits.

✅ Must-have for: Long-term support products, apps using many third-party packages, or tight CI/CD release cycles.

2. Cross-Version Compatibility Tester

This automated system uses the underlying version manager (like FVM or Puro) to sequentially check out multiple specified Flutter versions (e.g., latest stable, previous stable, latest beta) and runs your project’s test suite against each one. It outputs a clear compatibility report.

Example Output:

Wrapping Up

Managing multiple Flutter SDK versions is a common requirement, easily addressed by tools like FVM and Puro. FVM offers a straightforward, community-backed approach with per-project configuration. Puro provides a highly performant alternative focused on speed and resource efficiency using its environment system.

Choose the tool that best fits your workflow and priorities.

Why Flutter? Honestly, Why Not?

Turbocharged Performance 🚀

Flutter isn’t just fast; it’s “why doesn’t every app feel this smooth?” fast.

Thanks to Dart’s JIT and AOT magic, apps on your TV are about to be as responsive as your favorite smartphone apps.

One Codebase to Rule Them All 📝

Write once, run anywhere—iOS, Android, and now, webOS. LG is cutting down on development time and costs, which means we could see smarter smart TVs faster than ever.

A Plethora of Widgets 🎨

Flutter’s widget library is a UI designer’s dream. It’s about time our TVs got a facelift to match the sleek, modern look of our handheld devices.

Vast Community Support 🌍

Flutter’s community is a powerhouse, constantly creating tools and resources that make developers’ lives easier. LG is tapping into this vibrant ecosystem for faster, more innovative development cycles.

Decoding the Buzz: Why It’s a Bigger Deal Than You Think

Speedy Development Cycles 🏃‍♂️

Expect more frequent updates and new features on LG TVs, making the “smart” in smart TVs feel more genuine.

Enhanced User Experience 🌟

With Flutter, we’re talking about smoother animations and more responsive interfaces. Your interaction with your TV will be as intuitive as your smartphone.

Flutter’s Growing Footprint 📈

LG’s move might push other manufacturers to consider Flutter. It’s about time everyone realized web development isn’t just for browsers.

A New Playground for Developers 💼

New platforms mean new opportunities. For the developer community, especially in regions like India where Flutter skills are hot, this could lead to more jobs and innovative projects. Discussions suggest major development hubs in Asia, like LG Soft India, taking the lead in this venture.

Let’s Get Real

While we’re all excited about Flutter, let’s not overlook the challenges. Performance on underpowered hardware has been an issue, and if LG wants this to work, they need some serious hardware upgrades. We don’t need another “great on paper, poor in execution” scenario.

So, what do you think? Is this a bold strategic win for LG and Flutter, or just another headline grabber? Either way, it’s going to be interesting to see how this plays out in the competitive smart TV market.

Share your thoughts below, and let’s chat about it!

“Constraints go down, sizes go up, parent sets position.”

The Downward Flow of Constraints

The layout process begins with constraints that flow downwards from parent widgets to their children. These constraints are essentially rules set by the parent widget that dictate the maximum or minimum size its child widgets can have. This hierarchical structure helps in maintaining a consistent and logical layout across the user interface.

In practical terms, if you’re working with a framework like Flutter, understanding this concept means recognizing that a parent widget can significantly influence the display and behavior of its child widgets. For instance, a ‘Column’ widget might constrain its children to have the same width but allow different heights.

Sizes Ascend Upwards

Once constraints are set by the parent, each child widget determines its size within these limits. This size calculation is critical as it ensures that each widget uses the optimal amount of space, enhancing both aesthetics and functionality. The calculated sizes then ascend back up to the parent, informing it of the space requirements of each child.

This upward and downward communication ensures that all widgets are aligned perfectly and the overall layout looks clean and functions well. For example, in a dashboard UI, widget sizes determine how much data can be displayed within each section without overwhelming the user.

Positioning by the Parent

The final step in the layout process involves the parent widget positioning its children within the layout. This is where the parent’s role is most visible; it uses the size and constraint information to place each widget precisely where it needs to be. This could involve complex calculations when dealing with responsive or adaptive layouts that need to look good on any screen size.

Why This Matters

Understanding and applying this rule can make the difference between a UI that is functional and one that is both functional and visually appealing. It reduces the chances of encountering layout errors and makes debugging easier, as you can logically trace through how constraints and sizing are applied.

Ambeego Pulse

Ambeego Pulse provides an array of resources including guides, tips, and case studies. Having been involved with Flutter since its inception, the insights available through Ambeego Pulse are grounded in extensive experience and tailored to real-world applications.

If you found this explanation helpful, remember to save and share this post with others who might benefit.