diff --git a/phlex/core/product_query.hpp b/phlex/core/product_query.hpp
index 76f1919d8..8cf10fa2a 100644
--- a/phlex/core/product_query.hpp
+++ b/phlex/core/product_query.hpp
@@ -5,6 +5,7 @@
 #include "phlex/model/product_specification.hpp"
 #include "phlex/model/type_id.hpp"
 
+#include <concepts>
 #include <optional>
 #include <string>
 #include <tuple>
@@ -16,53 +17,27 @@ using namespace phlex::experimental::literals;
 namespace phlex {
   namespace detail {
     template <typename T>
-      requires std::is_same_v<experimental::identifier,
-                              T> // has to be a template for static_assert(false)
-    class required_creator_name {
+    class required {
     public:
-      required_creator_name()
-      {
-        static_assert(false, "The creator name has not been set in this product_query.");
-      }
-      required_creator_name(T&& rhs) : content_(std::move(rhs))
-      {
-        if (content_.empty()) {
-          throw std::runtime_error("Cannot specify product with empty creator name.");
-        }
-      }
-
-      operator T const&() const noexcept { return content_; }
-
-    private:
-      experimental::identifier content_;
-    };
-
-    template <typename T>
-      requires std::is_same_v<experimental::identifier,
-                              T> // has to be a template for static_assert(false)
-    class required_layer_name {
-    public:
-      required_layer_name()
-      {
-        static_assert(false, "The layer name has not been set in this product_query.");
-      }
-      required_layer_name(T&& rhs) : content_(std::move(rhs))
+      template <typename U>
+        requires std::constructible_from<T, U>
+      required(U&& u) : content_{std::forward_like<T>(u)}
       {
         if (content_.empty()) {
-          throw std::runtime_error("Cannot specify the empty string as a data layer.");
+          throw std::runtime_error("Cannot specify the empty string as a required field.");
         }
       }
 
       operator T const&() const noexcept { return content_; }
 
     private:
-      experimental::identifier content_;
+      T content_;
     };
   }
 
   struct product_query {
-    detail::required_creator_name<experimental::identifier> creator;
-    detail::required_layer_name<experimental::identifier> layer;
+    detail::required<experimental::identifier> creator;
+    detail::required<experimental::identifier> layer;
     std::optional<experimental::identifier> suffix;
     std::optional<experimental::identifier> stage;
     experimental::type_id type;
diff --git a/phlex/model/identifier.cpp b/phlex/model/identifier.cpp
index 1d1c2b2ff..9651ae236 100644
--- a/phlex/model/identifier.cpp
+++ b/phlex/model/identifier.cpp
@@ -18,6 +18,7 @@ namespace phlex::experimental {
     return h.result();
   }
 
+  identifier::identifier(char const* str) : identifier{std::string_view{str}} {}
   identifier::identifier(std::string_view str) : content_(str), hash_(hash_string(content_)) {}
 
   identifier::operator std::string_view() const noexcept { return std::string_view(content_); }
diff --git a/phlex/model/identifier.hpp b/phlex/model/identifier.hpp
index d78c638ac..cde13f9bc 100644
--- a/phlex/model/identifier.hpp
+++ b/phlex/model/identifier.hpp
@@ -24,6 +24,7 @@ namespace phlex::experimental {
     identifier(identifier const& other) = default;
     identifier(identifier&& other) noexcept = default;
 
+    identifier(char const* str);
     explicit identifier(std::string_view str);
 
     identifier& operator=(identifier const& rhs) = default;
diff --git a/test/allowed_families.cpp b/test/allowed_families.cpp
index 61985ccab..79cd0e43f 100644
--- a/test/allowed_families.cpp
+++ b/test/allowed_families.cpp
@@ -43,22 +43,22 @@ TEST_CASE("Testing families", "[data model]")
 
   // Wire up providers for each level
   g.provide("run_id_provider", provide_index, concurrency::unlimited)
-    .output_product(product_query{.creator = "dummy"_id, .layer = "run"_id, .suffix = "id"_id});
+    .output_product(product_query{.creator = "dummy", .layer = "run", .suffix = "id"});
   g.provide("subrun_id_provider", provide_index, concurrency::unlimited)
-    .output_product(product_query{.creator = "dummy"_id, .layer = "subrun"_id, .suffix = "id"_id});
+    .output_product(product_query{.creator = "dummy", .layer = "subrun", .suffix = "id"});
   g.provide("event_id_provider", provide_index, concurrency::unlimited)
-    .output_product(product_query{.creator = "dummy"_id, .layer = "event"_id, .suffix = "id"_id});
+    .output_product(product_query{.creator = "dummy", .layer = "event", .suffix = "id"});
 
   g.observe("se", check_two_ids)
-    .input_family(product_query{.creator = "dummy"_id, .layer = "subrun"_id, .suffix = "id"_id},
-                  product_query{.creator = "dummy"_id, .layer = "event"_id, .suffix = "id"_id});
+    .input_family(product_query{.creator = "dummy", .layer = "subrun", .suffix = "id"},
+                  product_query{.creator = "dummy", .layer = "event", .suffix = "id"});
   g.observe("rs", check_two_ids)
-    .input_family(product_query{.creator = "dummy"_id, .layer = "run"_id, .suffix = "id"_id},
-                  product_query{.creator = "dummy"_id, .layer = "subrun"_id, .suffix = "id"_id});
+    .input_family(product_query{.creator = "dummy", .layer = "run", .suffix = "id"},
+                  product_query{.creator = "dummy", .layer = "subrun", .suffix = "id"});
   g.observe("rse", check_three_ids)
-    .input_family(product_query{.creator = "dummy"_id, .layer = "run"_id, .suffix = "id"_id},
-                  product_query{.creator = "dummy"_id, .layer = "subrun"_id, .suffix = "id"_id},
-                  product_query{.creator = "dummy"_id, .layer = "event"_id, .suffix = "id"_id});
+    .input_family(product_query{.creator = "dummy", .layer = "run", .suffix = "id"},
+                  product_query{.creator = "dummy", .layer = "subrun", .suffix = "id"},
+                  product_query{.creator = "dummy", .layer = "event", .suffix = "id"});
   g.execute();
 
   CHECK(g.execution_count("se") == 1ull);
diff --git a/test/benchmarks/benchmarks_provider.cpp b/test/benchmarks/benchmarks_provider.cpp
index 953ece8a0..535e7b280 100644
--- a/test/benchmarks/benchmarks_provider.cpp
+++ b/test/benchmarks/benchmarks_provider.cpp
@@ -4,5 +4,5 @@ PHLEX_REGISTER_PROVIDERS(s)
 {
   using namespace phlex;
   s.provide("provide_id", [](data_cell_index const& id) { return id; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "id"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "id"});
 }
diff --git a/test/benchmarks/last_index.cpp b/test/benchmarks/last_index.cpp
index a39c6cda7..515741327 100644
--- a/test/benchmarks/last_index.cpp
+++ b/test/benchmarks/last_index.cpp
@@ -10,6 +10,6 @@ namespace {
 PHLEX_REGISTER_ALGORITHMS(m, config)
 {
   m.transform("last_index", last_index, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "id"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "id"})
     .output_products(config.get<std::string>("produces", "a"));
 }
diff --git a/test/benchmarks/read_id.cpp b/test/benchmarks/read_id.cpp
index 43bb85c83..5f4422c06 100644
--- a/test/benchmarks/read_id.cpp
+++ b/test/benchmarks/read_id.cpp
@@ -10,5 +10,5 @@ namespace {
 PHLEX_REGISTER_ALGORITHMS(m)
 {
   m.observe("read_id", read_id, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "id"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "id"});
 }
diff --git a/test/cached_execution.cpp b/test/cached_execution.cpp
index 369daa164..f4fba7830 100644
--- a/test/cached_execution.cpp
+++ b/test/cached_execution.cpp
@@ -61,37 +61,34 @@ TEST_CASE("Cached function calls", "[data model]")
 
   // Register providers
   g.provide("provide_number", provide_number, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "run"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "run", .suffix = "number"});
   g.provide("provide_another", provide_another, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "subrun"_id, .suffix = "another"_id});
+    .output_product(product_query{.creator = "input", .layer = "subrun", .suffix = "another"});
   g.provide("provide_still", provide_still, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "still"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "still"});
 
   g.transform("A1", call_one, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "run"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "run", .suffix = "number"})
     .output_products("one");
   g.transform("A2", call_one, concurrency::unlimited)
-    .input_family(product_query{.creator = "A1"_id, .layer = "run"_id, .suffix = "one"_id})
+    .input_family(product_query{.creator = "A1", .layer = "run", .suffix = "one"})
     .output_products("used_one");
   g.transform("A3", call_one, concurrency::unlimited)
-    .input_family(product_query{.creator = "A2"_id, .layer = "run"_id, .suffix = "used_one"_id})
+    .input_family(product_query{.creator = "A2", .layer = "run", .suffix = "used_one"})
     .output_products("done_one");
 
   g.transform("B1", call_two, concurrency::unlimited)
-    .input_family(
-      product_query{.creator = "A1"_id, .layer = "run"_id, .suffix = "one"_id},
-      product_query{.creator = "input"_id, .layer = "subrun"_id, .suffix = "another"_id})
+    .input_family(product_query{.creator = "A1", .layer = "run", .suffix = "one"},
+                  product_query{.creator = "input", .layer = "subrun", .suffix = "another"})
     .output_products("two");
   g.transform("B2", call_two, concurrency::unlimited)
-    .input_family(product_query{.creator = "A2"_id, .layer = "run"_id, .suffix = "used_one"_id},
-                  product_query{.creator = "B1"_id, .layer = "subrun"_id, .suffix = "two"_id})
+    .input_family(product_query{.creator = "A2", .layer = "run", .suffix = "used_one"},
+                  product_query{.creator = "B1", .layer = "subrun", .suffix = "two"})
     .output_products("used_two");
 
   g.transform("C", call_two, concurrency::unlimited)
-    .input_family(product_query{.creator = "B2"_id, .layer = "subrun"_id, .suffix = "used_two"_id},
-                  product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "still"_id})
+    .input_family(product_query{.creator = "B2", .layer = "subrun", .suffix = "used_two"},
+                  product_query{.creator = "input", .layer = "event", .suffix = "still"})
     .output_products("three");
 
   g.execute();
diff --git a/test/class_registration.cpp b/test/class_registration.cpp
index 4e8a0042f..ce0691284 100644
--- a/test/class_registration.cpp
+++ b/test/class_registration.cpp
@@ -60,21 +60,20 @@ namespace {
 TEST_CASE("Call non-framework functions", "[programming model]")
 {
   std::array const product_names{
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "number"_id},
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "temperature"_id},
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "name"_id}};
+    product_query{.creator = "input", .layer = "job", .suffix = "number"},
+    product_query{.creator = "input", .layer = "job", .suffix = "temperature"},
+    product_query{.creator = "input", .layer = "job", .suffix = "name"}};
   std::array const oproduct_names{"onumber"s, "otemperature"s, "oname"s};
 
   experimental::framework_graph g{data_cell_index::base_ptr()};
 
   // Register providers for the input products
   g.provide("provide_number", provide_number, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "number"});
   g.provide("provide_temperature", provide_temperature, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "temperature"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "temperature"});
   g.provide("provide_name", provide_name, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "name"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "name"});
 
   auto glueball = g.make<A>();
   SECTION("No framework")
diff --git a/test/configuration.cpp b/test/configuration.cpp
index 7c334af35..bcdb7f4fe 100644
--- a/test/configuration.cpp
+++ b/test/configuration.cpp
@@ -52,8 +52,8 @@ TEST_CASE("Retrieve product_query", "[config]")
   configuration config{underlying_config};
 
   auto input_query = config.get<product_query>("input");
-  CHECK(input_query.match(
-    product_query{.creator = "tracks_alg"_id, .layer = "job"_id, .suffix = "tracks"_id}));
+  CHECK(
+    input_query.match(product_query{.creator = "tracks_alg", .layer = "job", .suffix = "tracks"}));
   CHECK_THROWS_WITH(config.get<product_query>("malformed1"),
                     ContainsSubstring("Error retrieving parameter 'malformed1'") &&
                       ContainsSubstring("not a string"));
diff --git a/test/demo-giantdata/unfold_transform_fold.cpp b/test/demo-giantdata/unfold_transform_fold.cpp
index 1987815d2..80a9c9205 100644
--- a/test/demo-giantdata/unfold_transform_fold.cpp
+++ b/test/demo-giantdata/unfold_transform_fold.cpp
@@ -59,7 +59,7 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
                                spill_index.parent()->number(),
                                spill_index.number());
             })
-    .output_product(product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "wgen"_id});
+    .output_product(product_query{.creator = "input", .layer = "spill", .suffix = "wgen"});
 
   g.unfold<demo::WaveformGenerator>(
      "WaveformGenerator",
@@ -71,7 +71,7 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
      },
      concurrency::unlimited,
      "APA")
-    .input_family(product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "wgen"_id})
+    .input_family(product_query{.creator = "input", .layer = "spill", .suffix = "wgen"})
     .output_products("waves_in_apa");
 
   // Add the transform node to the graph
@@ -80,8 +80,8 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
   };
 
   g.transform("clamp_node", wrapped_user_function, concurrency::unlimited)
-    .input_family(product_query{
-      .creator = "WaveformGenerator"_id, .layer = "APA"_id, .suffix = "waves_in_apa"_id})
+    .input_family(
+      product_query{.creator = "WaveformGenerator", .layer = "APA", .suffix = "waves_in_apa"})
     .output_products("clamped_waves");
 
   // Add the fold node with instrumentation to detect pipelined execution
@@ -98,8 +98,7 @@ TEST_CASE("Unfold-transform-fold pipeline", "[concurrency][unfold][fold]")
      },
      concurrency::unlimited,
      "spill")
-    .input_family(
-      product_query{.creator = "clamp_node"_id, .layer = "APA"_id, .suffix = "clamped_waves"_id})
+    .input_family(product_query{.creator = "clamp_node", .layer = "APA", .suffix = "clamped_waves"})
     .output_products("summed_waveforms");
 
   // Execute the graph
diff --git a/test/different_hierarchies.cpp b/test/different_hierarchies.cpp
index b0fc3a143..0fa78058b 100644
--- a/test/different_hierarchies.cpp
+++ b/test/different_hierarchies.cpp
@@ -66,25 +66,22 @@ TEST_CASE("Different hierarchies used with fold", "[graph]")
 
   // Register provider
   g.provide("provide_number", provide_number, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "number"});
 
   g.fold("run_add", add, concurrency::unlimited, "run", 0u)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("run_sum");
   g.fold("job_add", add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("job_sum");
 
   g.observe("verify_run_sum", [](unsigned int actual) { CHECK(actual == 10u); })
-    .input_family(
-      product_query{.creator = "run_add"_id, .layer = "run"_id, .suffix = "run_sum"_id});
+    .input_family(product_query{.creator = "run_add", .layer = "run", .suffix = "run_sum"});
   g.observe("verify_job_sum",
             [](unsigned int actual) {
               CHECK(actual == 20u + 45u); // 20u from nested events, 45u from top-level events
             })
-    .input_family(
-      product_query{.creator = "job_add"_id, .layer = "job"_id, .suffix = "job_sum"_id});
+    .input_family(product_query{.creator = "job_add", .layer = "job", .suffix = "job_sum"});
 
   g.execute();
 
diff --git a/test/filter.cpp b/test/filter.cpp
index 51785a59d..49e045e0d 100644
--- a/test/filter.cpp
+++ b/test/filter.cpp
@@ -90,18 +90,18 @@ TEST_CASE("Two predicates", "[filtering]")
 {
   experimental::framework_graph g{source{10u}};
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("evens_only", evens_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("odds_only", odds_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.make<sum_numbers>(20u)
     .observe("add_evens", &sum_numbers::add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when("evens_only");
   g.make<sum_numbers>(25u)
     .observe("add_odds", &sum_numbers::add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when("odds_only");
 
   g.execute();
@@ -114,15 +114,15 @@ TEST_CASE("Two predicates in series", "[filtering]")
 {
   experimental::framework_graph g{source{10u}};
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("evens_only", evens_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("odds_only", odds_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when("evens_only");
   g.make<sum_numbers>(0u)
     .observe("add", &sum_numbers::add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when("odds_only");
 
   g.execute();
@@ -134,14 +134,14 @@ TEST_CASE("Two predicates in parallel", "[filtering]")
 {
   experimental::framework_graph g{source{10u}};
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("evens_only", evens_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("odds_only", odds_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.make<sum_numbers>(0u)
     .observe("add", &sum_numbers::add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when("odds_only", "evens_only");
 
   g.execute();
@@ -162,11 +162,11 @@ TEST_CASE("Three predicates in parallel", "[filtering]")
 
   experimental::framework_graph g{source{10u}};
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   for (auto const& [name, b, e] : configs) {
     g.make<not_in_range>(b, e)
       .predicate(name, &not_in_range::eval, concurrency::unlimited)
-      .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+      .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   }
 
   std::vector<std::string> const predicate_names{
@@ -174,7 +174,7 @@ TEST_CASE("Three predicates in parallel", "[filtering]")
   auto const expected_numbers = {4u, 5u, 7u};
   g.make<collect_numbers>(expected_numbers)
     .observe("collect", &collect_numbers::collect, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"})
     .experimental_when(predicate_names);
 
   g.execute();
@@ -186,28 +186,26 @@ TEST_CASE("Two predicates in parallel (each with multiple arguments)", "[filteri
 {
   experimental::framework_graph g{source{10u}};
   g.provide("provide_num", give_me_nums, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.provide("provide_other_num", give_me_other_nums, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "other_num"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "other_num"});
   g.predicate("evens_only", evens_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.predicate("odds_only", odds_only, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id});
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"});
   g.make<check_multiple_numbers>(5 * 100)
     .observe("check_evens", &check_multiple_numbers::add_difference, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "num"_id},
-                  product_query{.creator = "input"_id,
-                                .layer = "event"_id,
-                                .suffix = "other_num"_id}) // <= Note input order
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "num"},
+                  product_query{.creator = "input",
+                                .layer = "event",
+                                .suffix = "other_num"}) // <= Note input order
     .experimental_when("evens_only");
 
   g.make<check_multiple_numbers>(-5 * 100)
     .observe("check_odds", &check_multiple_numbers::add_difference, concurrency::unlimited)
     .input_family(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "other_num"_id},
-      product_query{
-        .creator = "input"_id, .layer = "event"_id, .suffix = "num"_id}) // <= Note input order
+      product_query{.creator = "input", .layer = "event", .suffix = "other_num"},
+      product_query{.creator = "input", .layer = "event", .suffix = "num"}) // <= Note input order
     .experimental_when("odds_only");
 
   g.execute();
diff --git a/test/filter_impl.cpp b/test/filter_impl.cpp
index dbf38048b..a9e6d4bb0 100644
--- a/test/filter_impl.cpp
+++ b/test/filter_impl.cpp
@@ -47,8 +47,8 @@ TEST_CASE("Filter data map", "[filtering]")
 {
   using phlex::product_query;
   std::vector const data_products_to_cache{
-    product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "a"_id},
-    product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "b"_id}};
+    product_query{.creator = "input", .layer = "spill", .suffix = "a"},
+    product_query{.creator = "input", .layer = "spill", .suffix = "b"}};
   data_map data{data_products_to_cache};
 
   // Stores with the data products "a" and "b"
diff --git a/test/fold.cpp b/test/fold.cpp
index d89d66b80..d66ac21da 100644
--- a/test/fold.cpp
+++ b/test/fold.cpp
@@ -53,29 +53,26 @@ TEST_CASE("Different data layers of fold", "[graph]")
   experimental::framework_graph g{driver_for_test(gen)};
 
   g.provide("provide_number", provide_number, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "number"});
 
   g.fold("run_add", add, concurrency::unlimited, "run")
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("run_sum");
   g.fold("job_add", add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("job_sum");
 
   g.fold("two_layer_job_add", add, concurrency::unlimited)
-    .input_family(product_query{.creator = "run_add"_id, .layer = "run"_id, .suffix = "run_sum"_id})
+    .input_family(product_query{.creator = "run_add", .layer = "run", .suffix = "run_sum"})
     .output_products("two_layer_job_sum");
 
   g.observe("verify_run_sum", [](unsigned int actual) { CHECK(actual == 10u); })
-    .input_family(
-      product_query{.creator = "run_add"_id, .layer = "run"_id, .suffix = "run_sum"_id});
+    .input_family(product_query{.creator = "run_add", .layer = "run", .suffix = "run_sum"});
   g.observe("verify_two_layer_job_sum", [](unsigned int actual) { CHECK(actual == 20u); })
-    .input_family(product_query{
-      .creator = "two_layer_job_add"_id, .layer = "job"_id, .suffix = "two_layer_job_sum"_id});
-  g.observe("verify_job_sum", [](unsigned int actual) { CHECK(actual == 20u); })
     .input_family(
-      product_query{.creator = "job_add"_id, .layer = "job"_id, .suffix = "job_sum"_id});
+      product_query{.creator = "two_layer_job_add", .layer = "job", .suffix = "two_layer_job_sum"});
+  g.observe("verify_job_sum", [](unsigned int actual) { CHECK(actual == 20u); })
+    .input_family(product_query{.creator = "job_add", .layer = "job", .suffix = "job_sum"});
 
   g.execute();
 
diff --git a/test/framework_graph.cpp b/test/framework_graph.cpp
index 3d8a75190..710b0b1f5 100644
--- a/test/framework_graph.cpp
+++ b/test/framework_graph.cpp
@@ -30,11 +30,10 @@ TEST_CASE("Make progress with one thread", "[graph]")
      "provide_number",
      [](data_cell_index const& index) -> unsigned int { return index.number(); },
      concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "spill", .suffix = "number"});
   g.observe(
      "observe_number", [](unsigned int const /*number*/) {}, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "number"_id});
+    .input_family(product_query{.creator = "input", .layer = "spill", .suffix = "number"});
   g.execute();
 
   CHECK(gen.emitted_cell_count("/job/spill") == 1000);
@@ -54,14 +53,13 @@ TEST_CASE("Stop driver when workflow throws exception", "[graph]")
        throw std::runtime_error("Error to stop driver");
      },
      concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "spill", .suffix = "number"});
 
   // Must have at least one downstream node that requires something of the
   // provider...otherwise provider will not be executed.
   g.observe(
      "downstream_of_exception", [](unsigned int) {}, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "number"_id});
+    .input_family(product_query{.creator = "input", .layer = "spill", .suffix = "number"});
 
   CHECK_THROWS(g.execute());
 
diff --git a/test/function_registration.cpp b/test/function_registration.cpp
index 4df01d462..36aa4e9d9 100644
--- a/test/function_registration.cpp
+++ b/test/function_registration.cpp
@@ -55,9 +55,9 @@ namespace {
 TEST_CASE("Call non-framework functions", "[programming model]")
 {
   std::array const product_names{
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "number"_id},
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "temperature"_id},
-    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "name"_id}};
+    product_query{.creator = "input", .layer = "job", .suffix = "number"},
+    product_query{.creator = "input", .layer = "job", .suffix = "temperature"},
+    product_query{.creator = "input", .layer = "job", .suffix = "name"}};
   std::array const oproduct_names = {"onumber"s, "otemperature"s, "oname"s};
   std::array const result{"result"s};
 
@@ -65,12 +65,11 @@ TEST_CASE("Call non-framework functions", "[programming model]")
 
   // Register providers
   g.provide("provide_number", provide_number, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "number"});
   g.provide("provide_temperature", provide_temperature, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "temperature"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "temperature"});
   g.provide("provide_name", provide_name, concurrency::unlimited)
-    .output_product(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "name"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "name"});
 
   SECTION("No framework")
   {
diff --git a/test/hierarchical_nodes.cpp b/test/hierarchical_nodes.cpp
index 012c8c829..0ec45b2b3 100644
--- a/test/hierarchical_nodes.cpp
+++ b/test/hierarchical_nodes.cpp
@@ -93,7 +93,7 @@ TEST_CASE("Hierarchical nodes", "[graph]")
               spdlog::info("Providing time for {}", index.to_string());
               return std::time(nullptr);
             })
-    .output_product(product_query{.creator = "input"_id, .layer = "run"_id, .suffix = "time"_id});
+    .output_product(product_query{.creator = "input", .layer = "run", .suffix = "time"});
 
   g.provide("provide_number",
             [](data_cell_index const& index) -> unsigned int {
@@ -101,30 +101,27 @@ TEST_CASE("Hierarchical nodes", "[graph]")
               auto const run_number = index.parent()->number();
               return event_number + run_number;
             })
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "number"});
 
   g.transform("get_the_time", strtime, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "run"_id, .suffix = "time"_id})
+    .input_family(product_query{.creator = "input", .layer = "run", .suffix = "time"})
     .experimental_when()
     .output_products("strtime");
   g.transform("square", square, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("squared_number");
 
   g.fold("add", add, concurrency::unlimited, "run", 15u)
-    .input_family(
-      product_query{.creator = "square"_id, .layer = "event"_id, .suffix = "squared_number"_id})
+    .input_family(product_query{.creator = "square", .layer = "event", .suffix = "squared_number"})
     .experimental_when()
     .output_products("added_data");
 
   g.transform("scale", scale, concurrency::unlimited)
-    .input_family(product_query{.creator = "add"_id, .layer = "run"_id, .suffix = "added_data"_id})
+    .input_family(product_query{.creator = "add", .layer = "run", .suffix = "added_data"})
     .output_products("result");
   g.observe("print_result", print_result, concurrency::unlimited)
-    .input_family(
-      product_query{.creator = "scale"_id, .layer = "run"_id, .suffix = "result"_id},
-      product_query{.creator = "get_the_time"_id, .layer = "run"_id, .suffix = "strtime"_id});
+    .input_family(product_query{.creator = "scale", .layer = "run", .suffix = "result"},
+                  product_query{.creator = "get_the_time", .layer = "run", .suffix = "strtime"});
 
   g.make<experimental::test::products_for_output>()
     .output("save", &experimental::test::products_for_output::save)
diff --git a/test/max-parallelism/check_parallelism.cpp b/test/max-parallelism/check_parallelism.cpp
index f57766be1..a56069f68 100644
--- a/test/max-parallelism/check_parallelism.cpp
+++ b/test/max-parallelism/check_parallelism.cpp
@@ -15,6 +15,5 @@ PHLEX_REGISTER_ALGORITHMS(m, config)
             [expected = config.get<std::size_t>("expected_parallelism")](std::size_t actual) {
               assert(actual == expected);
             })
-    .input_family(
-      product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "max_parallelism"_id});
+    .input_family(product_query{.creator = "input", .layer = "job", .suffix = "max_parallelism"});
 }
diff --git a/test/max-parallelism/provide_parallelism.cpp b/test/max-parallelism/provide_parallelism.cpp
index 6aad9ca0e..9cbe4b27f 100644
--- a/test/max-parallelism/provide_parallelism.cpp
+++ b/test/max-parallelism/provide_parallelism.cpp
@@ -7,6 +7,5 @@ PHLEX_REGISTER_PROVIDERS(s)
   s.provide(
      "provide_max_parallelism",
      [](data_cell_index const&) { return experimental::max_allowed_parallelism::active_value(); })
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "max_parallelism"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "max_parallelism"});
 }
diff --git a/test/memory-checks/many_events.cpp b/test/memory-checks/many_events.cpp
index 20fec2ee1..26315e95c 100644
--- a/test/memory-checks/many_events.cpp
+++ b/test/memory-checks/many_events.cpp
@@ -19,10 +19,9 @@ int main()
   experimental::framework_graph g{driver_for_test(gen)};
 
   g.provide("provide_number", [](data_cell_index const& id) -> unsigned { return id.number(); })
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "number"});
   g.transform("pass_on", pass_on, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "number"})
     .output_products("different");
   g.execute();
 }
diff --git a/test/mock-workflow/id_provider.cpp b/test/mock-workflow/id_provider.cpp
index 953ece8a0..535e7b280 100644
--- a/test/mock-workflow/id_provider.cpp
+++ b/test/mock-workflow/id_provider.cpp
@@ -4,5 +4,5 @@ PHLEX_REGISTER_PROVIDERS(s)
 {
   using namespace phlex;
   s.provide("provide_id", [](data_cell_index const& id) { return id; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "id"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "id"});
 }
diff --git a/test/multiple_function_registration.cpp b/test/multiple_function_registration.cpp
index c4d80909a..b356b88cb 100644
--- a/test/multiple_function_registration.cpp
+++ b/test/multiple_function_registration.cpp
@@ -45,51 +45,47 @@ TEST_CASE("Call multiple functions", "[programming model]")
 
   g.provide("provide_numbers",
             [](data_cell_index const&) -> std::vector<unsigned> { return {0, 1, 2, 3, 4}; })
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "numbers"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "numbers"});
   g.provide("provide_offset", [](data_cell_index const&) -> unsigned { return 6u; })
-    .output_product(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "offset"_id});
+    .output_product(product_query{.creator = "input", .layer = "job", .suffix = "offset"});
 
   SECTION("All free functions")
   {
     g.transform("square_numbers", square_numbers, concurrency::unlimited)
-      .input_family(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "numbers"_id})
+      .input_family(product_query{.creator = "input", .layer = "job", .suffix = "numbers"})
       .output_products("squared_numbers");
     g.transform("sum_numbers", sum_numbers, concurrency::unlimited)
-      .input_family(product_query{
-        .creator = "square_numbers"_id, .layer = "job"_id, .suffix = "squared_numbers"_id})
+      .input_family(
+        product_query{.creator = "square_numbers", .layer = "job", .suffix = "squared_numbers"})
       .output_products("summed_numbers");
     g.transform("sqrt_sum", sqrt_sum_numbers, concurrency::unlimited)
-      .input_family(product_query{.creator = "sum_numbers"_id,
-                                  .layer = "job"_id,
-                                  .suffix = "summed_numbers"_id},
-                    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "offset"_id})
+      .input_family(
+        product_query{.creator = "sum_numbers", .layer = "job", .suffix = "summed_numbers"},
+        product_query{.creator = "input", .layer = "job", .suffix = "offset"})
       .output_products("result");
   }
 
   SECTION("Transforms, one from a class")
   {
     g.transform("square_numbers", square_numbers, concurrency::unlimited)
-      .input_family(product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "numbers"_id})
+      .input_family(product_query{.creator = "input", .layer = "job", .suffix = "numbers"})
       .output_products("squared_numbers");
 
     g.transform("sum_numbers", sum_numbers, concurrency::unlimited)
-      .input_family(product_query{
-        .creator = "square_numbers"_id, .layer = "job"_id, .suffix = "squared_numbers"_id})
+      .input_family(
+        product_query{.creator = "square_numbers", .layer = "job", .suffix = "squared_numbers"})
       .output_products("summed_numbers");
 
     g.make<A>()
       .transform("sqrt_sum", &A::sqrt_sum, concurrency::unlimited)
-      .input_family(product_query{.creator = "sum_numbers"_id,
-                                  .layer = "job"_id,
-                                  .suffix = "summed_numbers"_id},
-                    product_query{.creator = "input"_id, .layer = "job"_id, .suffix = "offset"_id})
+      .input_family(
+        product_query{.creator = "sum_numbers", .layer = "job", .suffix = "summed_numbers"},
+        product_query{.creator = "input", .layer = "job", .suffix = "offset"})
       .output_products("result");
   }
 
   // The following is invoked for *each* section above
   g.observe("verify_result", [](double actual) { assert(actual == 6.); })
-    .input_family(
-      product_query{.creator = "sqrt_sum"_id, .layer = "job"_id, .suffix = "result"_id});
+    .input_family(product_query{.creator = "sqrt_sum", .layer = "job", .suffix = "result"});
   g.execute();
 }
diff --git a/test/output_products.cpp b/test/output_products.cpp
index a33a952f5..d19413391 100644
--- a/test/output_products.cpp
+++ b/test/output_products.cpp
@@ -42,15 +42,15 @@ TEST_CASE("Output data products", "[graph]")
   experimental::framework_graph g{driver_for_test(gen)};
 
   g.provide("provide_number", [](data_cell_index const&) -> int { return 17; })
-    .output_product(product_query{
-      .creator = "input"_id, .layer = "spill"_id, .suffix = "number_from_provider"_id});
+    .output_product(
+      product_query{.creator = "input", .layer = "spill", .suffix = "number_from_provider"});
 
   g.transform(
      "square_number",
      [](int const number) -> int { return number * number; },
      concurrency::unlimited)
-    .input_family(product_query{
-      .creator = "input"_id, .layer = "spill"_id, .suffix = "number_from_provider"_id})
+    .input_family(
+      product_query{.creator = "input", .layer = "spill", .suffix = "number_from_provider"})
     .output_products("squared_number");
 
   std::set<std::string> products_from_nodes;
diff --git a/test/plugins/ij_source.cpp b/test/plugins/ij_source.cpp
index 9c02ed37a..bf39ac329 100644
--- a/test/plugins/ij_source.cpp
+++ b/test/plugins/ij_source.cpp
@@ -5,7 +5,7 @@ using namespace phlex;
 PHLEX_REGISTER_PROVIDERS(s)
 {
   s.provide("provide_i", [](data_cell_index const& id) -> int { return id.number(); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "i"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "i"});
   s.provide("provide_j", [](data_cell_index const& id) -> int { return -id.number(); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "j"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "j"});
 }
diff --git a/test/plugins/module.cpp b/test/plugins/module.cpp
index e37f10f12..a1e4383d0 100644
--- a/test/plugins/module.cpp
+++ b/test/plugins/module.cpp
@@ -8,10 +8,10 @@ using namespace phlex;
 PHLEX_REGISTER_ALGORITHMS(m)
 {
   m.transform("add", test::add, concurrency::unlimited)
-    .input_family(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "i"_id},
-                  product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "j"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "i"},
+                  product_query{.creator = "input", .layer = "event", .suffix = "j"})
     .output_products("sum");
   m.observe(
      "verify", [](int actual) { assert(actual == 0); }, concurrency::unlimited)
-    .input_family(product_query{.creator = "add"_id, .layer = "event"_id, .suffix = "sum"_id});
+    .input_family(product_query{.creator = "add", .layer = "event", .suffix = "sum"});
 }
diff --git a/test/product_query.cpp b/test/product_query.cpp
index 11fa32147..15bb2d569 100644
--- a/test/product_query.cpp
+++ b/test/product_query.cpp
@@ -8,34 +8,33 @@ using namespace phlex;
 TEST_CASE("Empty specifications", "[data model]")
 {
   CHECK_THROWS_WITH(
-    (product_query{.creator = ""_id, .layer = "layer"_id}),
-    Catch::Matchers::ContainsSubstring("Cannot specify product with empty creator name."));
+    (product_query{.creator = "", .layer = "layer"}),
+    Catch::Matchers::ContainsSubstring("Cannot specify the empty string as a required field."));
   CHECK_THROWS_WITH(
-    (product_query{.creator = "creator"_id, .layer = ""_id}),
-    Catch::Matchers::ContainsSubstring("Cannot specify the empty string as a data layer."));
+    (product_query{.creator = "creator", .layer = ""}),
+    Catch::Matchers::ContainsSubstring("Cannot specify the empty string as a required field."));
   CHECK_THROWS_WITH(
-    (product_query{.creator = "creator"_id, .layer = "layer"_id}.spec()),
+    (product_query{.creator = "creator", .layer = "layer"}.spec()),
     Catch::Matchers::ContainsSubstring("Product suffixes are (temporarily) mandatory"));
 }
 
 TEST_CASE("Product name with data layer", "[data model]")
 {
-  product_query label({.creator = "creator"_id, .layer = "event"_id, .suffix = "product"_id});
+  product_query label({.creator = "creator", .layer = "event", .suffix = "product"});
   CHECK(label.creator == "creator"_id);
   CHECK(label.layer == "event"_id);
   CHECK(label.suffix == "product"_idq);
   // Mismatched creator
-  CHECK(!product_query{.creator = "1"_id, .layer = "event"_id, .suffix = "prod"_id}.match(
-    product_query{.creator = "2"_id, .layer = "event"_id, .suffix = "prod"_id}));
+  CHECK(!product_query{.creator = "1", .layer = "event", .suffix = "prod"}.match(
+    product_query{.creator = "2", .layer = "event", .suffix = "prod"}));
   // Mismatched layer
-  CHECK(!product_query{.creator = "1"_id, .layer = "event"_id, .suffix = "prod"_id}.match(
-    product_query{.creator = "1"_id, .layer = "event1"_id, .suffix = "prod"_id}));
+  CHECK(!product_query{.creator = "1", .layer = "event", .suffix = "prod"}.match(
+    product_query{.creator = "1", .layer = "event1", .suffix = "prod"}));
   // Mismatched suffix
-  CHECK(!product_query{.creator = "1"_id, .layer = "event"_id, .suffix = "prod"_id}.match(
-    product_query{.creator = "1"_id, .layer = "event"_id, .suffix = "prod1"_id}));
+  CHECK(!product_query{.creator = "1", .layer = "event", .suffix = "prod"}.match(
+    product_query{.creator = "1", .layer = "event", .suffix = "prod1"}));
   // Mismatched stage
   CHECK(
-    !product_query{.creator = "1"_id, .layer = "event"_id, .suffix = "prod"_id, .stage = "stage"_id}
-       .match(product_query{
-         .creator = "1"_id, .layer = "event"_id, .suffix = "prod"_id, .stage = "stage1"_id}));
+    !product_query{.creator = "1", .layer = "event", .suffix = "prod", .stage = "stage"_id}.match(
+      product_query{.creator = "1", .layer = "event", .suffix = "prod", .stage = "stage1"_id}));
 }
diff --git a/test/provider_test.cpp b/test/provider_test.cpp
index c5d597833..cdd02a0e8 100644
--- a/test/provider_test.cpp
+++ b/test/provider_test.cpp
@@ -40,11 +40,10 @@ TEST_CASE("provider_test")
 
   g.provide("my_name_here", give_me_vertices, concurrency::unlimited)
     .output_product(
-      product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "happy_vertices"_id});
+      product_query{.creator = "input", .layer = "spill", .suffix = "happy_vertices"});
 
   g.transform("passer", pass_on, concurrency::unlimited)
-    .input_family(
-      product_query{.creator = "input"_id, .layer = "spill"_id, .suffix = "happy_vertices"_id})
+    .input_family(product_query{.creator = "input", .layer = "spill", .suffix = "happy_vertices"})
     .output_products("vertex_data");
 
   g.execute();
diff --git a/test/python/source.cpp b/test/python/source.cpp
index 1bdcf54eb..0f681b622 100644
--- a/test/python/source.cpp
+++ b/test/python/source.cpp
@@ -7,58 +7,58 @@ using namespace phlex;
 PHLEX_REGISTER_PROVIDERS(s)
 {
   s.provide("provide_i", [](data_cell_index const& id) -> int { return id.number() % 2; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "i"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "i"});
   s.provide("provide_j",
             [](data_cell_index const& id) -> int { return 1 - (int)(id.number() % 2); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "j"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "j"});
   s.provide("provide_k", [](data_cell_index const&) -> int { return 0; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "k"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "k"});
 
   s.provide("provide_f1",
             [](data_cell_index const& id) -> float { return (float)((id.number() % 100) / 100.0); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "f1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "f1"});
   s.provide(
      "provide_f2",
      [](data_cell_index const& id) -> float { return 1.0f - (float)((id.number() % 100) / 100.0); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "f2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "f2"});
 
   s.provide(
      "provide_d1",
      [](data_cell_index const& id) -> double { return (double)((id.number() % 100) / 100.0); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "d1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "d1"});
   s.provide("provide_d2",
             [](data_cell_index const& id) -> double {
               return 1.0 - (double)((id.number() % 100) / 100.0);
             })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "d2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "d2"});
 
   s.provide(
      "provide_u1",
      [](data_cell_index const& id) -> unsigned int { return (unsigned int)(id.number() % 2); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "u1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "u1"});
   s.provide(
      "provide_u2",
      [](data_cell_index const& id) -> unsigned int { return 1 - (unsigned int)(id.number() % 2); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "u2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "u2"});
 
   s.provide("provide_l1", [](data_cell_index const& id) -> long { return (long)(id.number() % 2); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "l1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "l1"});
   s.provide("provide_l2",
             [](data_cell_index const& id) -> long { return 1 - (long)(id.number() % 2); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "l2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "l2"});
 
   s.provide(
      "provide_ul1",
      [](data_cell_index const& id) -> unsigned long { return (unsigned long)(id.number() % 101); })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "ul1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "ul1"});
   s.provide("provide_ul2",
             [](data_cell_index const& id) -> unsigned long {
               return 100 - (unsigned long)(id.number() % 101);
             })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "ul2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "ul2"});
 
   s.provide("provide_b1", [](data_cell_index const& id) -> bool { return (id.number() % 2) == 0; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "b1"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "b1"});
   s.provide("provide_b2", [](data_cell_index const& id) -> bool { return (id.number() % 2) != 0; })
-    .output_product(product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "b2"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "b2"});
 }
diff --git a/test/type_distinction.cpp b/test/type_distinction.cpp
index 6031825ac..7eece0ba8 100644
--- a/test/type_distinction.cpp
+++ b/test/type_distinction.cpp
@@ -57,53 +57,45 @@ TEST_CASE("Distinguish products with same name and different types", "[programmi
 
   // Register providers
   g.provide("provide_numbers", provide_numbers, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "numbers"});
   g.provide("provide_length", provide_length, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "length"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "length"});
 
   SECTION("Duplicate product name but differ in creator name")
   {
     g.observe("starter", [](int num) { spdlog::info("Received {}", num); })
-      .input_family(
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id});
+      .input_family(product_query{.creator = "input", .layer = "event", .suffix = "numbers"});
     g.transform("triple_numbers", triple, concurrency::unlimited)
-      .input_family(
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id})
+      .input_family(product_query{.creator = "input", .layer = "event", .suffix = "numbers"})
       .output_products("tripled");
     spdlog::info("Registered tripled");
     g.transform("expand_orig", expand, concurrency::unlimited)
-      .input_family(
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id},
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "length"_id})
+      .input_family(product_query{.creator = "input", .layer = "event", .suffix = "numbers"},
+                    product_query{.creator = "input", .layer = "event", .suffix = "length"})
       .output_products("expanded_one");
     spdlog::info("Registered expanded_one");
     g.transform("expand_triples", expand, concurrency::unlimited)
       .input_family(
-        product_query{.creator = "triple_numbers"_id, .layer = "event"_id, .suffix = "tripled"_id},
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "length"_id})
+        product_query{.creator = "triple_numbers", .layer = "event", .suffix = "tripled"},
+        product_query{.creator = "input", .layer = "event", .suffix = "length"})
       .output_products("expanded_three");
     spdlog::info("Registered expanded_three");
 
     g.transform("add_nums", add_numbers, concurrency::unlimited)
       .input_family(
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id},
-        product_query{.creator = "triple_numbers"_id, .layer = "event"_id, .suffix = "tripled"_id})
+        product_query{.creator = "input", .layer = "event", .suffix = "numbers"},
+        product_query{.creator = "triple_numbers", .layer = "event", .suffix = "tripled"})
       .output_products("sums");
     spdlog::info("Registered sums");
 
     g.transform("add_vect", add_vectors, concurrency::unlimited)
       .input_family(
-        product_query{
-          .creator = "expand_orig"_id, .layer = "event"_id, .suffix = "expanded_one"_id},
-        product_query{
-          .creator = "expand_triples"_id, .layer = "event"_id, .suffix = "expanded_three"_id})
+        product_query{.creator = "expand_orig", .layer = "event", .suffix = "expanded_one"},
+        product_query{.creator = "expand_triples", .layer = "event", .suffix = "expanded_three"})
       .output_products("sums");
 
     g.transform("extract_result", triple, concurrency::unlimited)
-      .input_family(
-        product_query{.creator = "add_nums"_id, .layer = "event"_id, .suffix = "sums"_id})
+      .input_family(product_query{.creator = "add_nums", .layer = "event", .suffix = "sums"})
       .output_products("result");
     spdlog::info("Registered result");
   }
@@ -111,19 +103,16 @@ TEST_CASE("Distinguish products with same name and different types", "[programmi
   SECTION("Duplicate product name and creator, differ only in type")
   {
     g.transform("square", square, concurrency::unlimited)
-      .input_family(
-        product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "numbers"_id})
+      .input_family(product_query{.creator = "input", .layer = "event", .suffix = "numbers"})
       .output_products("square_result", "square_result");
 
     g.transform("extract_result", id, concurrency::unlimited)
-      .input_family(
-        product_query{.creator = "square"_id, .layer = "event"_id, .suffix = "square_result"_id})
+      .input_family(product_query{.creator = "square", .layer = "event", .suffix = "square_result"})
       .output_products("result");
   }
 
   g.observe("print_result", [](int res) { spdlog::info("Result: {}", res); })
-    .input_family(
-      product_query{.creator = "extract_result"_id, .layer = "event"_id, .suffix = "result"_id});
+    .input_family(product_query{.creator = "extract_result", .layer = "event", .suffix = "result"});
   spdlog::info("Registered observe");
   g.execute();
   spdlog::info("Executed");
diff --git a/test/unfold.cpp b/test/unfold.cpp
index 461a9e11b..bccbdbf10 100644
--- a/test/unfold.cpp
+++ b/test/unfold.cpp
@@ -97,38 +97,32 @@ TEST_CASE("Splitting the processing", "[graph]")
   experimental::framework_graph g{driver_for_test(gen)};
 
   g.provide("provide_max_number", provide_max_number, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "max_number"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "max_number"});
   g.provide("provide_ten_numbers", provide_ten_numbers, concurrency::unlimited)
-    .output_product(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "ten_numbers"_id});
+    .output_product(product_query{.creator = "input", .layer = "event", .suffix = "ten_numbers"});
 
   g.unfold<iota>("iota", &iota::predicate, &iota::unfold, concurrency::unlimited, "lower1")
-    .input_family(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "max_number"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "max_number"})
     .output_products("new_number");
   g.fold("add", add, concurrency::unlimited, "event")
-    .input_family(
-      product_query{.creator = "iota"_id, .layer = "lower1"_id, .suffix = "new_number"_id})
+    .input_family(product_query{.creator = "iota", .layer = "lower1", .suffix = "new_number"})
     .output_products("sum1");
   g.observe("check_sum", check_sum, concurrency::unlimited)
-    .input_family(product_query{.creator = "add"_id, .layer = "event"_id, .suffix = "sum1"_id});
+    .input_family(product_query{.creator = "add", .layer = "event", .suffix = "sum1"});
 
   g.unfold<iterate_through>("iterate_through",
                             &iterate_through::predicate,
                             &iterate_through::unfold,
                             concurrency::unlimited,
                             "lower2")
-    .input_family(
-      product_query{.creator = "input"_id, .layer = "event"_id, .suffix = "ten_numbers"_id})
+    .input_family(product_query{.creator = "input", .layer = "event", .suffix = "ten_numbers"})
     .output_products("each_number");
   g.fold("add_numbers", add_numbers, concurrency::unlimited, "event")
-    .input_family(product_query{
-      .creator = "iterate_through"_id, .layer = "lower2"_id, .suffix = "each_number"_id})
+    .input_family(
+      product_query{.creator = "iterate_through", .layer = "lower2", .suffix = "each_number"})
     .output_products("sum2");
   g.observe("check_sum_same", check_sum_same, concurrency::unlimited)
-    .input_family(
-      product_query{.creator = "add_numbers"_id, .layer = "event"_id, .suffix = "sum2"_id});
+    .input_family(product_query{.creator = "add_numbers", .layer = "event", .suffix = "sum2"});
 
   g.make<experimental::test::products_for_output>().output(
     "save", &experimental::test::products_for_output::save, concurrency::serial);
diff --git a/test/vector_of_abstract_types.cpp b/test/vector_of_abstract_types.cpp
index ec7026108..929cb1b80 100644
--- a/test/vector_of_abstract_types.cpp
+++ b/test/vector_of_abstract_types.cpp
@@ -44,15 +44,13 @@ TEST_CASE("Test vector of abstract types")
 
   experimental::framework_graph g{driver_for_test(gen)};
   g.provide("provide_thing", [](data_cell_index const&) { return make_derived_as_abstract(); })
-    .output_product(
-      product_query{.creator = "dummy"_id, .layer = "event"_id, .suffix = "thing"_id});
+    .output_product(product_query{.creator = "dummy", .layer = "event", .suffix = "thing"});
   g.transform("read_thing", read_abstract)
-    .input_family(product_query{.creator = "dummy"_id, .layer = "event"_id, .suffix = "thing"_id})
+    .input_family(product_query{.creator = "dummy", .layer = "event", .suffix = "thing"})
     .output_products("sum");
   g.observe(
      "verify_sum", [](int sum) { CHECK(sum == 3); }, concurrency::serial)
-    .input_family(
-      product_query{.creator = "read_thing"_id, .layer = "event"_id, .suffix = "sum"_id});
+    .input_family(product_query{.creator = "read_thing", .layer = "event", .suffix = "sum"});
   g.execute();
 
   CHECK(g.execution_count("provide_thing") == 1);