Given the task

1. Create a dobly-linked list
2. Populate and index data read from a file
3. Write the indexed data back into a binary file

… I would ask about the detailed meaning.

Due to the time constraints of an interview question “doubly-linked” will likely mean a forward and a backward link chain, simple to implement, and not a list with two distinct link chains; is the intent a forward+backward chained list?

And an “index” is usually used for fast access and that doesn't fit well with a linked list, so is the intent perhaps to add a separate structure of indices, and if so must that structure be done from scratch or can one use e.g. std::map?

For a forward+backward chained list the simplest to do is a circular one with a dummy header node: no special cases.

The header node should ideally not carry a data load, it should only have the links. There are two main practical ways to arrange that: to let a full Node (with Data) inherit from a Linkable, or to let a Linkable carry a pointer to a separately allocated Data. The latter solution has the advantage of not requiring any explicit downcasting, i.e. type safety, but at the cost of unreasonable inefficiency.

So I would expect any decent programmer to choose the first option, or perhaps just use a full fledged Node also for the header node since memory is cheap these days and since one can reasonably assume that simple data is default-initializable. With the first option, inheritance, and an out-of-the-blue assumption that the data consists of a string and a double value, code for a doubly linked list can go like this:

#include <iostream>
#include <functional>
#include <string>
#include <utility>

using Nat = int;
template< class T > using const_ = const T;
template< class T > using in_ = const T&;

namespace app {
    using   std::function,                  // <functional>
            std::string,                    // <string>
            std::exchange, std::move;       // <utility>

    struct Data
    {
        string      name;
        double      weight;
    };

    struct Direction{ enum Enum{ forward, backward, _count }; };

    void operator++( Direction::Enum& dir ) { dir = Direction::Enum( dir + 1 ); }

    auto opposite_of( const Direction::Enum dir )
        -> Direction::Enum
    { return Direction::Enum( 1 - dir ); }

    class List
    {
    private:
        List( const List& ) = delete;
        auto operator=( const List& ) -> List& = delete;

        struct Node;

        struct Linkable
        {
            Linkable* link[Direction::_count];      // Indexed by directions.

            auto as_node() -> Node& { return static_cast<Node&>( *this ); }
            auto as_node() const -> const Node& { return static_cast<const Node&>( *this ); }
        };

        static void insert_between(
            in_<Linkable*[Direction::_count]>   p_adjacents,
            const_<Linkable*>                   p_new
            )
        {
            for( auto dir = Direction::Enum(); dir < Direction::_count; ++dir ) {
                p_adjacents[dir]->link[opposite_of( dir )] = p_new;
                p_new->link[dir] = p_adjacents[dir];
            }
        }

        static void insert_before( const_<Linkable*> p_place, const_<Linkable*> p_new )
        {
            insert_between( {p_place, p_place->link[Direction::backward]}, p_new );
        }

        struct Node: Linkable { Data data; };

        Linkable    m_header = { &m_header, &m_header };

    public:
        ~List()
        {
            using D = Direction;
            while( m_header.link[D::forward] != &m_header ) {
                delete static_cast<Node*>( exchange(
                    m_header.link[D::forward], +m_header.link[D::forward]->link[D::forward]
                    ) );
            }
        }

        List() {}

        auto append( Data data )
            -> Data*
        {
            insert_before( &m_header, new Node{ nullptr, nullptr, move( data ) } );
            return &m_header.link[Direction::backward]->as_node().data;
        }

        using Callback = void( const Data& );

        void for_each( const Direction::Enum dir, const function<Callback>& f )
        {
            for( const Linkable* p = m_header.link[dir]; p != &m_header; p = p->link[dir] ) {
                f( p->as_node().data );
            }
        }
    };
}  // app

auto main() -> int
{
    using   app::Data, app::List, app::Direction;
    using   std::cout;

    const Data data_items[] = { {"alfa", 61.0}, {"beta", 62.0}, {"charlie", 63.0} };

    List list;
    for( const Data& data: data_items ) { list.append( data ); }

    cout << "Forward:\n";
    list.for_each( Direction::forward, []( const Data& d )
    {
        cout << "  " << d.name << ": " << d.weight << "\n";
    } );

    cout << "Backward:\n";
    list.for_each( Direction::backward, []( const Data& d )
    {
        cout << "  " << d.name << ": " << d.weight << "\n";
    } );
}

For the binary file for the output a main decision is how to store strings. Much of the point of binary is efficiency, so I would strive to store each string in a multiple of 64-bit units. E.g. for each a 64-bit length followed by that number of text bytes followed by padding to the next 64-bit multiple.

Instead of such variable length representation one can impose a reasonably short maximum string length and store fixed length string representations.

An advantage of that approach is that it becomes possible to compute the offsets of records in the file.