DEV Community: Muhammd Rehman Tahir

FlowBased.NetCore v1.0.1 — Enterprise Documentation & Business Flow Management for .NET

Muhammd Rehman Tahir — Thu, 25 Jun 2026 17:39:41 +0000

I'm excited to announce the release of FlowBased.NetCore v1.0.1, now available on NuGet!

What is FlowBased.NetCore?

FlowBased.NetCore is a plug-and-play documentation and business flow management framework for ASP.NET Core applications. It gives you an embedded enterprise-grade documentation portal with zero frontend setup — just two lines of code and you're running.

Two-line integration

builder.Services.AddFlowBased();
app.UseFlowBased();

That's it. You now have:

A full admin dashboard with CRUD for applications, modules, and flows
A public documentation portal (separately themed, independently authenticated)
Markdown/HTML editing with a rich toolbar
File attachments with drag-and-drop
Automatic versioning on every edit
Full-text search
Technical dependency mapping (APIs, services, repositories, database tables)
Code snippet support
Dark mode

What's New in v1.0.1

Annotation-Driven Discovery

This release introduces three new attribute types that make it even easier to document and discover your application's architecture:

[BusinessFlow] — Mark classes that orchestrate business processes (e.g., CheckoutFlow, RefundFlow)
[Integration] — Mark classes that integrate with external providers (e.g., Stripe, PayPal, SendGrid)
[EventHandler] — Mark classes that handle domain events (e.g., OrderCreatedHandler, PaymentReceivedHandler)

These join the existing attribute family: [ApiEndpoint], [Service], [Repository], and [Entity].

New Discovery API Endpoints

The admin API now exposes:

Endpoint	Description
`GET /{prefix}/api/discovery/annotated/business-flows`	Classes with `[BusinessFlow]`
`GET /{prefix}/api/discovery/annotated/integrations`	Classes with `[Integration]`
`GET /{prefix}/api/discovery/annotated/event-handlers`	Classes with `[EventHandler]`

All seven annotation types are now discoverable via the API, and the admin dashboard's flow editor includes multi-select dropdowns for the new types.

Display Annotations on Enums

DocumentationType and FlowBasedRole now carry [Display(Name, Description)] attributes, making dropdown labels in the UI much more descriptive.

NuGet Packaging Fix

Sub-project DLLs are now bundled correctly into the NuGet package without requiring consumers to add them as separate NuGet dependencies.

Getting Started

Install

dotnet add package FlowBased.NetCore

Configure

using FlowBased.NetCore.AspNetCore.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddFlowBased(options =>
{
    options.Title = "My App Docs";
    options.RoutePrefix = "flowdocs";
    options.StoragePath = Path.Combine(builder.Environment.WebRootPath ?? "wwwroot", "FlowBasedDocs");
    options.EnableVersioning = true;
    options.AllowMarkdown = true;
});

var app = builder.Build();

// Seed demo data (optional)
using (var scope = app.Services.CreateScope())
{
    var service = scope.ServiceProvider.GetRequiredService<IFlowService>();
    await SeedData.SeedAsync(service);
}

app.UseFlowBased();
app.Run();

Annotate your code

[BusinessFlow("Order Processing", "Handles the complete order lifecycle")]
public class OrderProcessingService { ... }

[Integration("Stripe", "Stripe", "Payment processing via Stripe")]
public class StripePaymentGateway { ... }

[EventHandler("OrderCreated", "OrderCreated", "Sends notifications when an order is created")]
public class OrderCreatedHandler { ... }

The dashboard will automatically surface these annotations in the flow editor.

Features at a Glance

Zero-config embedded SPA — No npm, no webpack, no separate deployment
JSON file storage — No database required
Full-text search — Names, descriptions, tags, content
Automatic versioning — Every edit is a snapshot
File attachments — Drag-and-drop, paste, GUID storage
Markdown + HTML — Both content types, server-side Markdig rendering
Code snippets — Named, language-tagged examples
Technical dependency mapping — Link flows to APIs, services, repos, DB tables
Auto-discovery — Scans assemblies for controllers, services, repositories, entities, and now business flows, integrations, and event handlers
Lines-of-code estimation — Categorized by type
RBAC — 6-level role hierarchy with per-application permissions
Public documentation portal — Read-only, separately themed, independently auth-controlled
Dark mode — Independent toggles for admin and docs portal
Custom branding — Accent color, title, route prefix
Broad compatibility — Works with .NET 6 through .NET 10

Package Details


Package	FlowBased.NetCore
Version	1.0.1
License	MIT
Author	Muhammad Rehman Tahir
Repository	github.com/MRehmanTahir/FlowBased.NetCore
Target	net8.0+ (Shared library targets netstandard2.1)

What's Next

buildTransitive support for automatic using directives
Searchable annotation dropdowns in the flow editor (already in the dashboard UI)
Further API refinements based on feedback

Give it a try and let me know what you think! Feedback, issues, and PRs are welcome on GitHub.

Built by Muhammad Rehman Tahir

🚀 2-Minute Testing Technique That Finds 80–90% Bugs (Build a QA Mindset as a Developer)

Muhammd Rehman Tahir — Sat, 06 Jun 2026 16:59:53 +0000

In QA, there is a super fast and practical 2-minute testing approach that helps you quickly identify most critical bugs before deep testing even begins. I personally use this method, and it has completely changed the way I look at software quality.

I call it: CRUD + Boundary + Abuse + Performance Scan

It focuses on quickly validating a feature from all key angles:

🔹 Happy Path (CRUD Check)
First, verify the basics:
Does the feature Create, Read, Update, Delete work properly?
Are search and filters functioning as expected?

🔹 Boundary Testing
Test extreme and invalid inputs:
Empty values, max length, special characters, negative numbers, decimals, invalid formats.

🔹 Abuse Testing
Try to break the system:
Double clicks, rapid actions, refresh, back button, multiple tabs, duplicate submissions.

🔹 Quick Performance & UI Scan
Check load time, UI breakage, responsiveness, error messages, console errors, and bulk data handling.

Golden Rule:
Ask these 7 questions on every screen:
✔ Does data save correctly?
✔ Is invalid data blocked?
✔ Can duplicates happen?
✔ Can unauthorized access occur?
✔ Does refresh/back break anything?
✔ Is performance acceptable?
✔ Is UI stable in all scenarios?

This simple 2-minute scan can reveal 80–90% of system issues early, just like senior QA engineers do using quick “smoke testing” techniques.

How I Fixed "A Possible Object Cycle Was Detected" in ASP.NET Core (And What I Learned About DTOs)

Muhammd Rehman Tahir — Thu, 16 Apr 2026 04:44:13 +0000

Yesterday I ran into a classic but dangerous issue while working on an ASP.NET Core API:

👉 "A possible object cycle was detected"

At first, everything was working fine… until I introduced some additional logic on top of my existing response. Suddenly, my API started failing during JSON serialization.

After digging deeper, I realized the root cause:

❌ I was directly returning EF Core entities
❌ Navigation properties created a circular reference
❌ The serializer went into an infinite loop

The structure looked something like this:
Entity → Navigation → Entity → Navigation → 🔁

💥 Boom — Object Cycle Error!

🔍 How I resolved it:

Instead of sending the full entity graph to the frontend, I:

✔ Trimmed the entity to only required properties
✔ Broke the circular reference manually
✔ Understood the importance of separating API models from DB models

🚀 Key Learning:

This issue made one thing very clear:

DTOs are not optional — they are essential.

Using DTOs helps you:
✔ Avoid circular reference issues
✔ Keep your API responses clean and controlled
✔ Improve performance
✔ Maintain proper architecture

⚠️ Developer Tip:

If you're exposing EF entities directly in APIs, you're just one change away from breaking your system.

Think long-term. Avoid quick fixes.

💬 Have you ever faced this issue in your APIs?

I just published my second NuGet package: Rehman.CurrencyTextify.Core

Muhammd Rehman Tahir — Wed, 11 Mar 2026 17:06:22 +0000

This lightweight and flexible package converts money amounts into text for 8 currencies: Dollar, Euro, Pound, Yen, Rupee, Rial, Dirham, and Dinar — now including PKR!

✨ Key Features:

Batch processing
Fuzzy spelling correction
Custom rounding modes
Capitalization styles
Subunit name overrides
Handling negative amounts

Whether you’re building financial apps, invoices, or reports, this package makes working with currencies in code fast, simple, and reliable.

💡 I’d love for you to try it out and share your feedback!

🔗 Check it out on NuGet : https://www.nuget.org/packages/Rehman.CurrencyTextify.Core/