Naming

Make sure the names of variables, functions and types are meaningful and precise, otherwise your code will just be confusing for others, and in half a year when you have forgotten the details of the code you wrote today, it will become confusing for you as well.

• absolute(): this does more than computing the absolute value, it calculates the absolute value of the difference of two values. So: absolute_difference() would be better, or abs_diff() if you want to abbreviate it.
• find_index(): it not only finds an index, it also inserts a value into the vector entries. If the index that you return is not used most of the time, then I'd name this function insert(), just like how std::vector::insert() inserts and element and also returns an iterator.
• Value, Entry: these are very generic names. If you define them in the global namespace, that is going to be a problem in a larger codebase, where there might be other things that are values and entries. Either make these names more distinct, or put them into a class or namespace.

Create a class representing a ring buffer

The code calling find_index() needs to declare the vector of entries, as well as the begin and end pointers. These are then passed to find_index(). That's quite annoying to do, and it's easy to make mistakes. It's better to create a class that manages everything, so that main() would just become:

int main()
{
    RingBuffer<Value> ring_buffer(10);
    auto index = ring_buffer.insert(5);
    assert(index == 0);
    …
}

This class would look like:

template<typename Entry>
class RingBuffer {
    using Value = decltype(Entry::value);
    std::vector<Entry> m_data;
    T* m_begin{};
    T* m_end{};

public:
    RingBuffer(std::size_t size): m_data(size) {}

    auto insert(Value value) -> std::ptrdiff_t
    {
        …
    }
};

Ideally, RingBuffer would look and work as much as possible as other STL containers, although that might be quite a bit of work to accomplish.

What is the point of Entry?

I'm not sure why you have a struct Entry that just wraps a Value. Why not store the entries in a std::vector<Value>? Unless of course you want to store other data as well in the ring buffer, and Value itself is just a kind of index as well. If that is the case, I'd rather make your class look like this:

template<typename T>
class RingBuffer {
    std::vector<T> m_data;
    constexpr std::size_t npos = -1;
    std::size_t m_begin{npos}; // position in m_data that contains the lowest index
    std::size_t m_end{npos};   // position in m_data that contains the highest index
    std::size_t m_lowest_index{};  // value of the lowest index

public:
    RingBuffer(std::size_t size): m_data(size) {}

    auto insert(std::size_t index, const T& value)
    {
        if (m_begin == npos) {
            m_begin = m_end = 0;
            m_lowest_index = index;
            m_data[m_begin] = value;
            return /* iterator? success? */;
        }
        …
    }
};

Of course, now that the index is separate from the rest of the data, and in fact not even stored in Entry anymore, you also need some function to read back data stored at a given index. You could create an operator[] for that.

Error handling

It's easy to forget that the returned index might not be a valid one. If the caller doesn't check it, then it could try to access entries[-1], which in the best case causes a the program to crash, in the worst case it will behave in unexpected ways. There are better ways to return success or failure:

• Consider throwing an exception in case the insertion failed. The drawback is that this should only be done if that would really be an exceptional case; if it's expected that the ring buffer will fill up over time during normal use, then perhaps this is not the best approach.
• Return a std::optional, or since C++23, a std::expected.
• Rename the function to try_find_index() or try_insert() to indicate that success is not guaranteed.