I use this pattern fairly regularly in a variety of ways. Here's a quick piece of example code that might help explain this a bit better. I'm writing this example in C#, but I usually work in other languages (Java / ruby / Python / JS),

before:

  public Student GetStudentById(int id)
  {
    var record = db.findStudentById(id)
    if (record == null) return null;
    return new Student(record.id, record.name, ...);
  }

Then in say a student record controller class:

  public View Get(int id)
  {
    var student = getStudentById(id);
    if (student == null) return View("NotFound");
    return View("Display", student);
  }

After:

  [ContractAnnotation("=> notnull")]
  public StudentSearchResult GetStudentById(int id)
  {
    var record = db.findStudentById(id);
    if (record == null) return StudentSearchRsult.NotFound;
    return new StudentSearchResult(record.id, record.name, ...);
  }

Then:

  public View Get(int id)
  {
    var student = getStudentById(id);
    return new View(student.ViewName, student); // look no null check becase student.ViewName is always valid here
  }

Note: of course this is entirely simplified for the purposes of example. Perhaps your real world example doesn't return null from the db, but a RecordSet with either 0 or 1 elements. Perhaps your db uses exceptions that you translate into results like this.

The cool thing there is that you get tool support (from e.g. ReSharper) telling your that this is entirely safe to do without a null check and tool support when it's not.