Scientific notation in Base-16
JavaScript (ES6),  134 124  121 bytes
Expects a float and returns an array of 2 strings.
n=&gt;([x,y]=(+(g=n=&gt;s=n.toString(16))(n).replace(r=/[1-f]/g,1)).toExponential().split`e`,[x.replace(r,_=&gt;r.exec(s)),g(+y)])

Try it online!
How?
We first convert the input to hexadecimal and save the result in the variable s.
For instance, 7.257672195146994e93 is turned into:
&quot;deadbeef0000000000000000000000000000000000000000000000000000000000000000000000&quot;

We replace all non-zero hexadecimal digits with 1's:
&quot;111111110000000000000000000000000000000000000000000000000000000000000000000000&quot;

We coerce this back to an integer and invoke the .toExponential() method:
&quot;1.1111111e+77&quot;

We split this string into x = &quot;1.1111111&quot; and y = &quot;+77&quot;.
We replace all 1's in x with the non-zero hexadecimal digits of s in order of appearance:
&quot;d.eadbeef&quot;

Finally, we convert y to hexadecimal:
&quot;4d&quot;

Below is another example with 6e-19:
&quot;0.000000000000000b116b7de48f008&quot;
&quot;0.00000000000000011111111111001&quot;
&quot;1.1111111111001e-16&quot;
[ &quot;1.1111111111001&quot;, &quot;-16&quot; ]
[ &quot;b.116b7de48f008&quot;, &quot;-10&quot; ]

Commented
n =&gt; (                       // n = input
  [x, y] =                   // x = mantissa, y = exponent
    (                        //
      +(                     // coerce to integer:
        g = n =&gt;             //   g is a helper function converting its input ...
          s = n.toString(16) //     ... to a hexadecimal string saved in s
      )(n)                   //   invoke g with n
      .replace(              //   replace:
        r = /[1-f]/g,        //     r = regular expression to match the non-zero
                             //         hexa digits
        1                    //     replace all of them with 1's
      )                      //   end of replace()
    )                        //
    .toExponential()         // convert to exponential notation 
    .split`e`,               // split into [ x, y ] = [ mantissa, exponent ]
  [                          // output array:
    x.replace(               //   replace in x:
      r,                     //     use r a 2nd time to match the 1's
      _ =&gt; r.exec(s)         //     use r a 3rd time to get the next hexa digit
                             //     from s, this time taking advantage of the
                             //     stateful nature of RegExp
    ),                       //   end of replace()
    g(+y)                    //   convert y to hexadecimal
  ]                          // end of output array
)                            //