Let's Build: CQRS and MediatR Pattern using ASP.Net WEB API - Related to measure, content, mediatr, obsidian:, build:

How To Test And Measure Content In UX

The goal of content design is to reduce confusion and improve clarity. Yet often it’s difficult to pinpoint a problem as user feedback tends to be not specific enough. But: we can use a few simple techniques to assess how users understand and perceive content. Let’s take a look. Part of The goal of content design is to reduce confusion and improve clarity. Yet often it’s difficult to pinpoint a problem as user feedback tends to be not specific enough. But: we can use a few simple techniques to assess how users understand and perceive content. Let’s take a look. Part of How To Measure UX & Design Impact by yours truly.

Content testing is a simple way to test the clarity and understanding of the content on a page — be it a paragraph of text, a user flow, a dashboard, or anything in between. Our goal is to understand how well customers actually perceive the content that we present to them.

It’s not only about finding pain points and things that cause confusion or hinder clients from finding the right answer on a page but also about if our content clearly and precisely articulates what we actually want to communicate.

This article is part of our ongoing series on UX. You can find more details on design patterns and UX strategy in Smart Interface Design Patterns 🍣 — with live UX training coming up soon. Free preview.

Banana Testing: Replace all key actions with the word “Banana,” then ask customers to suggest what it could be. (Large preview).

A great way to test how well your design matches a user’s mental model is Banana Testing. We replace all key actions with the word “Banana,” then ask people to suggest what each action could prompt.

Not only does it tell you if key actions are understood immediately and if they are in the right place but also if your icons are helpful and if interactive elements such as links or buttons are perceived as such.

Content heatmapping, a simple technique to evaluate content and how well it performs. (Large preview).

One reliable technique to assess content is content heatmapping. The way we would use it is by giving participants a task, then asking them to highlight things that are clear or confusing. We could define any other dimensions or style lenses as well: [website], phrases that bring more confidence and less confidence.

Then we map all highlights into a heatmap to identify patterns and trends. You could run it with print-outs in person, but it could also happen in Figjam or in Miro remotely — as long as your tool of choice has a highlighter feature.

These little techniques above help you discover content issues, but they don’t tell you what is missing in the content and what doubts, concerns, and issues consumers have with it. For that, we need to uncover user needs in more detail.

Too often, individuals say that a page is “clear and well-organized,” but when you ask them specific questions, you notice that their understanding is vastly different from what you were trying to bring into spotlight.

Such insights rarely surface in unmoderated sessions — it’s much more effective to observe behavior and ask questions on the spot, be it in person or remote.

Removing doubts before they happen with front-loading key details. (Large preview).

Before testing, we need to know what we want to learn. First, write up a plan with goals, end-consumers, questions, script. Don’t tweak words alone — broader is advanced. In the session, avoid speaking aloud as it’s usually not how people consume content. Ask questions and wait silently.

After the task is completed, ask customers to explain the product, flow, and concepts to you. But: don’t ask them what they like, prefer, feel, or think. And whenever possible, avoid the word “content” in testing as customers often perceive it differently.

There are plenty of different tests that you could use:

Replace key actions with “bananas,” ask to explain.

🍌 Replace key actions with “bananas,” ask to explain. Cloze test 🕳️.

Remove words from your copy, ask customers to fill in the blanks.

🕳️ Remove words from your copy, ask customers to fill in the blanks. Reaction cards 🤔.

Write up emotions on 25 cards, ask clients to choose.

🤔 Write up emotions on 25 cards, ask clients to choose. Card sorting 🃏.

Ask clients to group topics into meaningful categories.

🃏 Ask clients to group topics into meaningful categories. Highlighting 🖍️.

Ask individuals to highlight helpful or confusing words.

🖍️ Ask individuals to highlight helpful or confusing words. Competitive testing 🥊.

Ask individuals to explain competitors’ pages.

When choosing the right way to test, consider the following guidelines:

Interviews, highlighting, Cloze test Do we match the mental model?

Banana testing, Cloze test What word works best?

Card sorting, A/B testing, tree testing Why doesn’t it work?

Interviews, highlighting, walkthroughs Do we know user needs?

In many tasks, there is rarely anything more impactful than the careful selection of words on a page. However, it’s not only the words alone that are being used but the voice and tone that you choose to communicate with end-people.

Use the techniques above to test and measure how well people perceive content but also check how they perceive the end-to-end experience on the site.

Quite often, the right words used incorrectly on a key page can convey a wrong message or provide a suboptimal experience. Even though the rest of the product might perform remarkably well, if a user is blocked on a critical page, they will be gone before you even blink.

New: How To Measure UX And Design Impact.

Meet Measure UX & Design Impact (8h), a new practical guide for designers and UX leads to measure and show your UX impact on business. Use the code 🎟 IMPACT to save 20% off today. Jump to the details.

So far, 2025 has been the year of AI agents — where generative AI technology is used to automate actions. We’ve seen OpenAI’s Operator debut, demonstr......

Shell scripting is a powerful tool for automation, system administration, and software deployment. However, as your shell scripts grow in size and com......

🍽️ Obsidian: Restaurant's rating

I have a very bad memory, which is why I am so obsessed with having systems that make it easier for me to search for information. Many times, if I don't structure it very well, I won't remember how I saved it and will end up losing it anyway. This is a big part of why I like Obsidian so much as a tool; it allows me to structure things in a way very similar to how I do it mentally, meaning in relationships.

Due to this same lack of memory, I have encountered situations where, for example, I am someone who does not tolerate spicy food very well. So, when I go to a restaurant and want to order chilaquiles, I don't remember if last time I ordered the green ones and they were too spicy, or if they were fine, or if the red ones were advanced, etc. To solve this, as in many other areas of my life, I have a system that helps me organize this information so that I can revisit it easily the next time I go to the restaurant. This way, I can see if I liked something, what details it had, how much I liked it, etc.

Restaurant: The establishment or chain. Dish: The specific dish I am going to rate. Journal: This is usually linked thanks to the fact that in my Journal I log my meals.

I create a note for the restaurant because this will be the note I visit when I return to that place. Additionally, I use this note so that, when creating a new dish, it can be linked to the restaurant it belongs to.

The structure is very simple. For this example, I will use my note about McDonald's.

--- tags: - place - restaurant --- # 📌 McDonald's ## ⭐ Recommendations Enter fullscreen mode Exit fullscreen mode.

```dataview TABLE calificacion as "Rating" FROM [[]] WHERE calificacion ``` Enter fullscreen mode Exit fullscreen mode.

## 🎫 Last Visit Enter fullscreen mode Exit fullscreen mode.

```dataview LIST WITHOUT ID link(dateformat([website], "dd-MM-yyyy")) FROM [[]] SORT [website] DESC LIMIT 1 ``` Enter fullscreen mode Exit fullscreen mode.

Now let's break down each part of the note.

The restaurant notes have the following tags:

Because my system includes various types of places, such as companies, it is necessary to make the distinction that it is a restaurant.

The recommendations are nothing more than a Dataview view that compiles all Dish notes, which we will see later, and displays them along with the rating I assigned. As shown in the image, I am a big fan of McDonald's.

Finally, this section simply searches for the most recent entry that references the establishment and demonstrates me the corresponding note for that date.

This is one of the parts I like the least because it requires me to explicitly mention the establishment in my Journal note. I want to improve the query so that it detects when I reference a dish linked to the establishment, but I haven't had time to do so.

This note refers to the dish itself. I use this note from the restaurant, linking the note to the restaurant in the title to later retrieve the rating, but also to store nutritional information about the dish. This is more related to the nutrition aspect, so I won’t cover it here.

--- calificacion: 5 tags: - dish --- # 🥘 McMuffin Regular from [[McDonald's]] My opinion on the food. Any *detail* I should remember. ## 📊 Nutritional Information [Calories:: 310 kcal] [Proteins:: 12 g] [Fats:: 13 g] [Carbohydrates:: 20 g] [Fiber:: 2 g] [Sugars:: 2 g] Enter fullscreen mode Exit fullscreen mode.

The dish has the tag dish to make it easier to filter in queries. Additionally, I include the rating in the metadata on a scale from 1 to 5.

In the body of the note, I can include any relevant information, such as whether the food was too spicy, if I should order it without tomato, or anything I want to remember for my next visit.

I won’t show my journal because it contains private information, and besides, there isn’t much complexity to it. It simply involves mentioning the restaurant note in my journal entry.

Once again, this is the part of the system that I like the least because it only works if it’s my first time at the place and I create dish notes, or if I make an explicit mention.

If you have a advanced idea on how to ensure that each time I mention a dish note in my meals section, it gets "logged" as a visit, I would be very grateful if you left me a comment.

This system in Obsidian has allowed me to improve my organization and memory regarding restaurants and dishes I have tried. Although it has some areas for improvement, such as automating the last visit, its modular structure has been quite useful. In the end, the essential thing is to have a system that adapts to my needs and can evolve over time. If you have suggestions on how to improve this methodology, I would love to hear them. Thanks for your time! 😊.

Concurrency has always been a cornerstone of modern software development, enabling applications to handle multiple tasks simultaneously. In Java, trad......

User interface (UI) design has evolved significantly over the years, focusing on efficiency, accessibility, and user experience. One emerging principl......

The latest release of the Go language, Go [website], introduces several crucial functions, including generic type aliases, weak pointers, improved cleanup......

Let's Build: CQRS and MediatR Pattern using ASP.Net WEB API

In this article, we will be implementing the MediatR and CQRS (Command Query Responsibility Segregation) pattern in our [website] Web API project.

CQRS stands for Command Query Responsibility segregation:

This is a design pattern that separates read(Query) and Write(Command) operations in a system to improve performance and scalability.

The command side handles create, upgrade and delete requests and the query side handles the Get request.

Acts as a bridge between command and query operations, helping with coordination. It facilitates communication between components by introducing a central handler. Instead of components interacting directly, they send requests to the mediatR, which routes them to the appropriate handler. The main goal of the MediatR pattern is to reduce dependencies between objects by restricting direct communication. This improves maintainability and scalability.

When a command or query is sent, the mediatR directs the request to the corresponding handler, which then processes either a command (write operation) or a query (read operation).

Applying CQRS and MediatR in Our Project(Iwallet Api).

From our previous project, where we built an iWallet using [website] Web API_ [website] we will now refactor it to utilize the CQRS pattern with the MediatR pattern.

Install MediatR from the NuGet package in Microsoft Visual Studio or by using the .NET CLI in Visual Studio Code:

Register or inject MediatR in the application's entry point ([website] as follows:

builder.Services.AddMediatR(cfg=>cfg.RegisterServicesFromAssemblies(typeof(Program).Assembly));

Create a folder named “Queries”, where the read operations are defined.

Create a class GetAllTransactionsQuery that inherit from the IRequest.

The generic type Tresponse represents the expected response can be of any type in this case >.

using MediatR ; using Wallet_API . Models ; namespace Wallet_API . Queries { public class GetAllTransactionsQuery : IRequest < IEnumerable < DailyExpense >> { } } Enter fullscreen mode Exit fullscreen mode.

Create a folder named "Handlers", where the implementation logic for queries and commands will be written.

Create class _GetAllTransactionHandler _that implements the IRequestHandler.

Inject the Iwallet interface used to fetch the transactions and the Imapper for DTO Transformations.

Then implement the IRequestHandler Interface handle method to call the GetTransactions method implemented by the Iwallet interface and return the list of expenses.

namespace Wallet_API . Handlers { public class GetAllTransactionHandler : IRequestHandler < GetAllTransactionsQuery , IEnumerable < DailyExpense >> { protected readonly IWallet _wallet ; protected readonly IMapper _mapper ; public GetAllTransactionHandler ( IWallet wallet , IMapper mapper ) { _wallet = wallet ; _mapper = mapper ; } public async Task < IEnumerable < DailyExpense >> Handle ( GetAllTransactionsQuery request , CancellationToken cancellationToken ) { var expenses = await _wallet . GetTransactions (); return expenses ; } } } Enter fullscreen mode Exit fullscreen mode.

Step [website] Define the HTTP GET Endpoint in the Controller.

Define the HTTP Get EndPoint in the controller.

Instantiate the query option (GetAllTransactionsQuery).

MediatR dispatches the request to the corresponding handler (GetAllTransactionHandler). The handler in this case _GetAllTransactionHandler _ then processes the request and returns a response.

[website] → Sends a request and may return a response and is one sender to only one handler.

_mediatR.Publish()-> publish has no return type and is One sender to many handlers.

Modify your controller to include MediatR as a dependency. Inject IMediator in the constructor to use it for handling requests.

public class DailyTransactionsController : ControllerBase { private readonly IMediator _mediatR ; public DailyTransactionsController ( IMediator mediator ) { _mediatR = mediator ; } [ HttpGet ] public async Task < ActionResult < IEnumerable < DailyExpenseDto >>> GetTransactions () { var query = new GetAllTransactionsQuery (); var result = await _mediatR . Send ( query ); return Ok ( result ); } } Enter fullscreen mode Exit fullscreen mode.

This section implements the functionality of getting the transaction by name.

On the Queries folder Create a new class GetTransactionNameNameQuery and Inherit from the IRequest .

. The query requires the _TransactionName _as a parameter.

Create a constructor to accept and initialize the TransactionName.

. Inject dependencies (IWallet and IMapper).

Return _null _if no transaction is found.

Step [website] Define the HTTP GET by Name Endpoint in the Controller.

Define the [HttpGet("TransactionByName/{TransactionName}")] route.

The route expects a string TransactionName.

Use [website] to dispatch the request. When the request is sent via MediatR, it carries the TransactionName, which is then used inside the handler to fetch the relevant data.

to dispatch the request. When the request is sent via MediatR, it carries the TransactionName, which is then used inside the handler to fetch the relevant data If no result is found, return NotFound(). Otherwise, return Ok(result).

Step [website] Create a Folder for Commands.

Create a folder named "Commands", where the write operations will be defined.

This section implements the functionality to add a new transaction.

Create a class CreateTransactionRequest that inherits from IRequest.

The generic type TResponse represents the expected response, which can be of any type. In this case, it will be DailyExpense.

Define the incoming request, which is a DailyExpenseDto, then create a constructor.

namespace Wallet_API . Commands { public class CreateTransactionRequest : IRequest < DailyExpense > { public DailyExpenseDto ExpenseDto { get ; } public CreateTransactionRequest ( DailyExpenseDto expenseDto ) { ExpenseDto = expenseDto ; } } } Enter fullscreen mode Exit fullscreen mode.

Step [website] Create a Handler for the Command.

Create a new handler CreateTransactionHandler that implements IRequestHandler .

. Like previous handlers, inject the required dependencies: IWallet and IMapper.

Implement the Handle method to add a new transaction.

Use AutoMapper to map DailyExpenseDto to DailyExpense.

Call the AddTransaction method to save the transaction.

namespace Wallet_API . Handlers { public class GetNewTransactionHandler : IRequestHandler < CreateTransactionRequest , DailyExpense > { protected readonly IWallet _wallet ; protected readonly IMapper _mapper ; public GetNewTransactionHandler ( IWallet wallet , IMapper mapper ) { _wallet = wallet ; _mapper = mapper ; } public async Task < DailyExpense > Handle ( CreateTransactionRequest request , CancellationToken cancellationToken ) { var expense = _mapper . Map < DailyExpense > ( request . ExpenseDto ); await _wallet . AddTransaction ( expense ); return _mapper . Map < DailyExpense > ( expense ); } } } Enter fullscreen mode Exit fullscreen mode.

Step [website] Define the HTTP POST Endpoint in the Controller.

The route expects a DailyExpenseDto object.

Instantiate _CreateTransactionRequest _with the provided expenseDto.

Use [website] to send the command, which will be handled by CreateTransactionHandler.

public async Task < ActionResult < DailyExpenseDto >> AddTransaction ([ FromBody ] DailyExpenseDto dailyExpenseDto ) { var command = new CreateTransactionRequest ( dailyExpenseDto ); var createdTransaction = await _mediatR . Send ( command ); return Ok ( createdTransaction ); } Enter fullscreen mode Exit fullscreen mode.

This format also works for both HTTP DELETE and enhancement operations.

DELETE _would use a command like DeleteTransactionRequest, which takes an TransactionName.

enhancement _would use UpdateTransactionRequest, which takes an updated DailyExpenseDto.

The CQRS and MediatR design patterns are great for scaling, especially in complex projects, as they enhance maintainability.

Thank you for reading ❤️ Stay awesome! 🚀.

Geoff’s post about the CSS Working Group’s decision to work on inline conditionals inspired some drama in the comments section. Some developers are ex......

Makulu Linux is a Linux distribution you’ve probably never heard of, which is a shame because it’s pretty cool. This flavor of Linux is based on Debia......

Svelte 5 And The Future Of Frameworks: A Chat With Rich Harris.

After months of anticipation, debate, and even......