Q:

How to get instant feedback on a change in CQRS

Let's assume I have the next pseudo code to implement Command based change in terms of CQRS (actually, Event Sourcing is questionable as well) in my WebApi project:
public IHttpActionResult ChangeVendor(ChangeVendorModel changeModel)
{
    /* 1 */ // user input validation
    /* 2 */ var changeCommand = changeModel.MapTo<ChangeVendorCommand>();   
    /* 3 */ bus.Send(changeCommand); // start the change processing
    /* 4 */ return Ok(); 
}

The explanation:

We perform a basic user input validation (as string length or only
    positive numbers) but not a business validation (as this Vendor is
    in the black list).
We convert the input model to a command for a bus.
We send the prepared change command through the bus to be processed.
By this we mean the change was applied and a domain model is
available for the further manipulations.

The questions:
a. The bus processing is asynchronous. How can I be sure (after step 4)
    that my changes were applied and the app is ready to render success
    view displaying a changed record from a database designed for
    querying purposes?
b. Let's say the record version conflict happened (data violation) or a model was not passed through the business rules (domain violation). How can I instantly notify a user about this from the bus? In a bad designed system, a user could see a successful result because we successfully scheduled the change on the bus and later on they could see the notification with an error when the attempt to apply the actual change was made.

A:

As I suggested in the comments you could wait for the event which signals completion and only return to the user when this is received. Some pseudo code:
public IHttpActionResult ChangeVendor(ChangeVendorModel changeModel)
{        
    var changeCommand = changeModel.MapTo<ChangeVendorCommand>();   
    bus.Send(changeCommand); // start the change processing
    var replyReceived=false;
    bool success = false;
    while(!replyreceived)
    {
        Task vendorChanged = Task.Factory.StartNew(()=> 
            {
                 var reply=bus.Receive<VendorChanged>());
                 if(reply.CorrelationToken==changeCommand.CorrelationToken)
                 {
                      replyReceived=true;
                      success=true;
                 }
            },SomeTimeout);
        Task vendorChangedFailed = Task.Factory.StartNew(()=> 
            {
                 var reply=bus.Receive<VendorChangeFailed>());
                 if(reply.CorrelationToken==changeCommand.CorrelationToken)
                 {
                      replyReceived=true;
                      success=false;
                 }
            },SomeTimeout());
        Task.WaitAny(new Task[]{vendorChanged,vendorChangeFailed});

    }
    if(success)
    {
        return Ok(); 
    }
    else
    { 
        return ChangeVendorFailed();
    }
}

obviously the receive needs to be on its own subscription, to ensure it doesn't take replies for other instances, and you may be able to create the subscription to receive only messages with the correct correlation token or other identifying property, but this gives you sopme idea of one way to skin this cat and make your tasky async workflow look syncronous to the user

