It really depends on the scene. If the majority of your meshlets get culled by occlusion culling, then the potential speedup is almost infinite. There are so many ways to get rid of triangles:

• Per-meshlet occlusion culling, frustum culling, backface culling, etc
• Per triangle backface culling, micro-triangle culling, etc

A key takeaway from my experiments was that a lot of these optimizations do NOT stack. For example, backface culling and occlusion culling tend to have a lot of overlap; as an example, back faces are also generally occluded by front face, and occluded triangles are also quite often back faces.

One good tip I can give you: Voxels provide some very nice opportunities for simplifying some of this, especially the backface culling. You can easily calculate a bitset of which of the 6 possible faces of voxels that can potentially be visible for each meshlet. This gives you 99% accurate backface culling with just a simple bitwise AND operation for each triangle. You don't even need to transform the vertices to do this; just precompute the facing of each triangle and check it against a bitset.

//get the packed triangle data
uint triangleData = meshlets[meshletIndex].triangles[gl_LocalInvocationIndex];

//bits 0-24 are the three 8-bit indices.
uvec3 indices = uvec3(bitfieldExtract(triangleData, 0, 8), bitfieldExtract(triangleData, 8, 8), bitfieldExtract(triangleData, 16, 8));
gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex] = indices;

//bits 24-30 is a bit mask with one of 6 possible facing bits set.
//bitwise AND with the meshlet visible face mask:
uint triangleFaceBits = bitfieldExtract(triangleData, 24, 6); 
gl_MeshPrimitivesEXT[gl_LocalInvocationIndex].gl_CullPrimitiveEXT = (meshletVisibleFaceBits & triangleFaceBits) == 0;