We first assume that the language A which you want to have a compiler for is suitable for writing compilers. If not (say the language is FORTRAN, or zsh shell scripts), then you won't ever write a compiler for A in the language A, so there will be no bootstrapping.
Otherwise, since you don't have a compiler for A, you can't write an A-compiler in the language A because you can't compile the compiler, and therefore can't compile any A programs including the compiler. That's where bootstrapping comes in: You write a compiler for the A-language in language B, which is suitable for writing compilers. When you are done, you have an A-compiler of unknown quality. Then you can write an A-compiler in the A-language and compile it with the A-compiler written in the B-language. Once you have that, you can forget about B completely.
You improve your A-compiler written in the A language by adding any missing features that the compiler written in B didn't support. When your compiler supports a new feature, then it can use the new feature. Then you can improve the compiler by making it generate faster code. Once you've done that, you compile your A compiler with the version that generates faster code, and you get an A compiler that runs faster.
Since generating faster code can cost time, you may add a switch to the compiler to either generate code as quickly as possible, or to generate the fastest possible code. Once you have this, you can compile the A compiler with a setting "generate the fastest possible code". Compiling the compiler may take a while, but you now have a compiler that runs at the highest possible speed, and generates the fastest possible code. But while you develop the compiler, you will use the setting that generates code as quickly as possible, so you can produce new compiler versions quickly. These compiler versions will be able to compile quickly or to generate good code, but will take longer to do so. But once you have a compiler you want to ship, you compile it with the option to produce the fastest possible code.
So the end result will be a compiler that runs as fast as possible, and can generate slow code quickly, or can generate fast code more slowly. So there is no cost from the fact that you used bootstrapping.
Now there might be the situation that your language A is inherently more complicated than language B. For example by having extra overhead because variables have no type. In that case, a compiler written in A might be slower than one written in B. But that means we are back to the first case, where language A is not as suitable for writing compilers as language B.
Another problem is that A might be very suitable for writing compilers, but you already have B compilers for various languages X, Y and Z, and it is easier to create a compiler for A by modifying a compiler for X, Y or Z. So you will have to do less work by creating A in language B by modifying one of the available compilers and end up with four compilers for X, Y, Z and A written in the B language.