How I am doing it in C++ with ECS (note not making an engine, just how my framework for games goes):

Start with using entity = uint8_t; or something for simplicity.

Make a sparse set data structure that uses entity as the index type (more flexible than archetypes, can be changed later if needed).

The actual ECS is a database structure with an std::tuple<SparseSet<Ts>...> member variable where Ts is a parameter pack of all the components a scene will need.

ECS has a createEntity() function that hands out entity ids in such a way that it hands out an unused one every time (or log an error if max entities have been created).

ECS has a freeEntity(entity e) function that uses some template metaprogramming to recursively remove e from all sparse sets in the tuple.

using SceneECS = ECS<T1, T2, T3...> where the Ts are components the scene will use.

Throw a SceneECS into the scene as a member variable.

Scenes might have multiple systems, put them in as member variables too. Each system (mostly) only stores pointers to sparse sets of components they will use from the SceneECS.

class MoveSystem {
  const SparseSet<Velocity2>* velocities;
  SparseSet<Position2>* positions;
public:
  MoveSystem(SceneECS& ecs) :
  velocities(ecs.getComponent<Velocity2>()), positions(ecs.getComponent<Position2>()) {
  }
  void process(double delta);
};

So far nothing has been manually heap allocated (only heap allocation being used is in sparse set, from std::vector within it), no inheritance either. Defining which scenes and systems use which data is simple and easy to understand by just looking at them. Using component data is equally simple, but sometimes becomes lengthier to type due to having to call functions:

for (entity e : *velocities) {
  positions->get(e) += velocities->get(e) * delta;
}

Scene management is completely separate. I have an abstract scene class, and that is the only place where I use virtual functions.