diff --git a/exercises/lifetimes/lifetimes4.rs b/exercises/lifetimes/lifetimes4.rs
new file mode 100644
index 00000000..7257856f
--- /dev/null
+++ b/exercises/lifetimes/lifetimes4.rs
@@ -0,0 +1,54 @@
+// lifetimes4.rs
+//
+// Sometimes, we have structs which hold on to data temporarily. A use-case of
+// this could be a routing component which accepts a connection and returns it to
+// another recipient. To avoid copying the data, we just accept a reference with
+// lifetime and return this reference later.
+//
+// In the example below, we create a `Router` instance in a limited scope. It
+// accepts a connection reference created in the enclosing scope and returns it.
+// In theory, this should be possible given that the connection reference outlives
+// the scope from which it is returned. However the borrow checker does not
+// seem to understand it. What can we do about that?
+//
+// Execute `rustlings hint lifetimes4` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+struct Router<'a> {
+    connection: Option<&'a u64>,
+}
+
+impl<'a> Router<'a> {
+    fn new() -> Self {
+        Self { connection: None }
+    }
+
+    fn accept_connection(&mut self, connection: &'a u64) {
+        self.connection = Some(connection);
+    }
+
+    fn return_connection(&mut self) -> Option<&u64> {
+        self.connection.take()
+    }
+}
+
+fn main() {
+    let connection = &123;
+
+    let returned_connection = {
+        // Create router within scope.
+        let mut router = Router::new();
+
+        // Accept connection which lives longer than the router.
+        router.accept_connection(connection);
+
+        // Return connection which **should** live longer than the router.
+        router.return_connection()
+    };
+
+    if let Some(connection) = returned_connection {
+        println!("The connection is {connection}");
+    }
+}
diff --git a/info.toml b/info.toml
index 5690701d..88891831 100644
--- a/info.toml
+++ b/info.toml
@@ -876,6 +876,25 @@ hint = """
 If you use a lifetime annotation in a struct's fields, where else does it need
 to be added?"""
 
+[[exercises]]
+name = "lifetimes4"
+path = "exercises/lifetimes/lifetimes4.rs"
+mode = "compile"
+hint = """
+The compiler complains that the `Router` is dropped at the end of the smaller
+scope while still being borrowed. However, we never intended to return a borrow
+to the `Router`. What are we really returning from
+`Router::return_connection`?
+
+The method `Router::return_connection` only takes `&mut self`
+and returns `Option<&u64>`. No explicit lifetimes are specified. What lifetime
+will the borrow checker assume for the `&u64` in the `Option`? You may want to
+re-read the chapter on lifetime elision:
+https://doc.rust-lang.org/reference/lifetime-elision.html
+
+What lifetime do we really want the `Option<&u64>` to have? Can we make that
+explicit?"""
+
 # TESTS
 
 [[exercises]]