Efficient drawing of primitives in openGL ES 2.0

I am writing a game on Android and it is running well. I try to keep everything as efficient as possible, so I store as much as I can in Vertex Buffer Objects to avoid unnecessary CPU overhead. However, the simple act of drawing a lot of unbound primitives or even variable length sprites efficiently (like drawing text on the screen) eludes me.

The purpose of these primitives is menus and buttons, as well as text.

For drawing the menu, I could just create an array of vertices for each item (menu background, buttons, etc.), but since they are all just squares, this seems very inefficient. I could also create a drawQuad () function that lets you just transparently load one saved vertex array with data for xy / height & width / color / texture / whatever. However, reloading each element of the array with new coordinates and different data every time to copy it to the Float Buffer (for the C ++ guys this is a special step you have to take in Java to transfer data to GL), so I can send it to the GPU also feels a lack of efficiency, although I don't know how else I could have done it. (One efficiency improvement I could see is to set square coordinates as a unit square,and then use Uniforms to scale it, but that seems immodest).

For text, this is even worse, since I don't know how long the text will be and I don't want to create large buffers for larger text (forcing the GC to randomly start later). An alternative option is to draw each letter with an independent draw command, but this also seems very inefficient even for a hundred letters on the screen (since I read that you should try to have as few draw commands as possible).

It is also possible that I was looking too deeply for the necessary openGL optimizations, but don't want me to get into a corner early with some awful design.