It was a lazy Sunday afternoon. I was polishing up a new feature in my Flutter fitness tracking app dynamically generating a daily step report from stored walking data. The goal? Simple: display something like this:

📅 May 26, 2025
🚶 Steps: 7,431
🔥 Calories: 292.4
📏 Distance: 5.6 km

Since I just needed to stitch together a few strings, I did what any developer might do:

String report = '';
report += '📅 $date\n';
report += '🚶 Steps: $steps\n';
report += '🔥 Calories: $calories\n';
report += '📏 Distance: $distance\n';

It worked. Until it didn’t.

The App Slowed Down… But why?

After a few test walks and generating several reports, I noticed the app started feeling sluggish. Not crash-level slow just… laggy.

I checked the logs, memory usage, and even questioned the pedometer plugin.

Spoiler: the issue was that innocent little + operator I’d sprinkled everywhere.

The Hidden Cost of + in Dart

Here’s what I didn’t realize back then:

Every time you concatenate strings using +, Dart creates a new string object in memory*. Strings in Dart are **immutable**.*

In my report builder, I was concatenating several strings — over and over again — every time the user viewed their daily summary.

Worse? When I moved this into a loop to show weekly stats, the app choked hard.

String weeklyReport = '';
for (final day in history) {
  weeklyReport += '📅 ${day.date}\n';
  weeklyReport += '🚶 Steps: ${day.steps}\n\n';
}

This loop was silently allocating hundreds of unnecessary string objects. No wonder it lagged.

The Fix: StringBuffer to the Rescue

Then I discovered StringBuffer. I wish I had known about it sooner.

Here’s how I refactored that same logic:

final buffer = StringBuffer();

for (final day in history) {
  buffer.writeln('📅 ${day.date}');
  buffer.writeln('🚶 Steps: ${day.steps}\n');
}

final weeklyReport = buffer.toString();

Suddenly:

• The lag vanished.

• The memory usage dropped.

• The code actually looked cleaner.

I was building one mutable buffer instead of thousands of immutable strings.

Real Results in My Flutter App

After switching to StringBuffer, here's what improved:

• Performance: Generating a week’s report became instant.

• Memory usage: No more bloated allocations from +.

• Code clarity: Easier to read and maintain.

Even the UI felt smoother. All because of one tiny change.

Where This Matters in Real Apps

This isn’t just a niche case. Many real-world Flutter apps involve large or repetitive string operations.

Examples:

• Chat apps generating long chat logs

• Invoice/reporting tools formatting dynamic data

• HTML or JSON builders assembling templates

• Markdown or documentation tools converting rich text

In all these cases, replacing + with StringBuffer can yield noticeable performance improvements especially on lower-end devices or with large datasets.

When Should You Use + vs StringBuffer?

Use + :

• Simple strings (2–3 parts)

• Static UI labels

• Readability > performance

Use StringBuffer :

• Loops building dynamic text

• Logs, reports, summaries

• Anywhere performance matters

The Takeaway

If you’re building anything dynamic in Dart a summary, report, message builder, log system does yourself a favor:

Use StringBuffer from the start.

I learned it the hard way, so you don’t have to.

Final Words

Sometimes the smallest tools have the biggest impact. StringBuffer won’t just improve your performance it’ll make you think differently about how you build text in your Flutter apps.

So next time you’re reaching for that +... ask yourself: is this a story worth buffering?

Over to You

Have you ever hit a performance wall from something seemingly harmless? Share your story in the comments. I’d love to hear how you debugged it!