I have business objects, that I would like to (de)serialize from and into a .yaml file.
Because I want the .yaml to be human readable, I need a certain degree of control over the serialize and deserialize methods.
Where should the serialization logic go?
A) If I teach every object, how to de/serialize itself, but that probably violates the single-responsibility-principle.
B) If I put it inside a common serialization module, that might violate the open-closed-principle, since more business objects will be added in the future. Also, changes to objects need now be performed in two places.
What is the SOLID approach to solve this conundrum for tiny-scale applications?
Usually in this kind of situation, you'll want the business objects to handle their own serialization.  This doesn't necessarily violate the single responsibility principle, which asserts that each object should have one job and one boss.  It just means that the one job includes serializability.  The user owns the business object, and wants to be able to serialize it, so the requirement for serializability comes from the same place as those other requirements -- the user.
There are a couple danger areas, though.  Firstly, do you really need to insist that the business object is serializable, or can you leave it up to the user to decide whether they are serializable or not?  If you are imposing a serializability requirement, then there's a good chance that your are violating the SRP that way, because as you evolve the serialization system, you will be imposing your own requirements on the objects.
Second, you probably want to think long and hard about the interface the these objects use to serialize themselves.  Does it have to be yaml?  Why?  Does it have to be to a file?  Try not to impose requirements that are subject to change, because they depend on particular implementation decisions that you're making in the rest of the system.  That ends up being a violation of SRP as well, because they those objects have to evolve according to requirements from 2 different sources.  It's better if the objects themselves initiate their own serialization, and can choose the implementation to the greatest extent possible.
Where to put *serialization* in SOLID programming