Backward Euler formula:
\[ y_{n+1} = y_n + (x_{n+1} - x_n ) f(x_{n+1}) \qquad \mbox{or} \qquad y_{n+1} = y_n + h\,f_{n+1} , \]
where h is the step size (which is assumed to be fixed, for simplicity) and \( f_{n+1} = f \left( x_{n+1}, y_{n+1} \right) . \)

Example: Consider the following initial value problem:

\[ y' = y^3 - 3\,t , \qquad y(0) =1 . \]
Here is the Mathematica code that solve this problem:
y[0] = 1.;        (* initial condition *)
h = 0.1;          (* step size *)
t[0] = 0.;        (* starting vaue of the independent value *)
M = Round[0.5/h];       (* number of points to reach the final destination, in our case it is 0.5    *)
toler = h;      (* define the tolerance *)
Do[
  t[n + 1] = t[n] + h;
  eqn = (z == y[n] + h (z^3 - 3 t[n + 1]) );
  ans = z /. NSolve[eqn, z, Reals];
  indlist = {};
  toler = h;
 While[ Length[indlist] == 0, 
  toler = toler*2.;
  indlist = Flatten[Position[Map[(Abs[y[n] - #] < toler) &, ans], True]];
  ];
  ind = indlist[[1]];
  y[n + 1] = ans[[ind]];
  , {n, 0, M}]

Then we plot solution:
ListPlot[Table[{t[n], y[n]}, {n, 0, M}], PlotStyle->PointSize[0.025]]
y[M]
t[M]

NSolve has to spend time to compute all roots to the equation (which can be computationally expensive). FindRoot does a pretty fast search looking for only a single root, so it is quick for complex equations.
If you care about all possible roots, or if you have no clue where the roots of the equation may be, FindRoot is a terrible choice. If you only care about a single root and have a rough idea of where it might be, though, FindRoot will find it quickly.