diff --git a/docs/src/main/asciidoc/qute-reference.adoc b/docs/src/main/asciidoc/qute-reference.adoc
index 33ae9229fc32b..e9713c453f07e 100644
--- a/docs/src/main/asciidoc/qute-reference.adoc
+++ b/docs/src/main/asciidoc/qute-reference.adoc
@@ -1279,6 +1279,8 @@ A CDI bean annotated with `@Named` can be referenced in any template through `cd
 <1> First, a bean with name `personService` is found and then used as the base object.
 <2> First, a bean with name `foo` is found and then used as the base object.
 
+NOTE: `@Named @Dependent` beans are shared across all expressions in a template for a single rendering operation, and destroyed after the rendering finished.
+
 All expressions with `cdi` and `inject` namespaces are validated during build.
 For the expression `cdi:personService.findPerson(10).name` the implementation class of the injected bean must either declare the `findPerson` method or a matching <<template_extension_methods,template extension method>> must exist.
 For the expression `inject:foo.price` the implementation class of the injected bean must either have the `price` property (e.g. a `getPrice()` method) or a matching <<template_extension_methods,template extension method>> must exist.
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/PropertyNotFoundDevModeTest.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/PropertyNotFoundDevModeTest.java
index 2eb14743b3e15..7f5fcbe56d0c7 100644
--- a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/PropertyNotFoundDevModeTest.java
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/PropertyNotFoundDevModeTest.java
@@ -26,10 +26,10 @@ public class PropertyNotFoundDevModeTest {
 
     @Test
     public void testExceptionIsThrown() {
-        assertEquals("Entry \"foo\" not found in the data map in expression {foo.surname} in template foo on line 1",
+        assertEquals("Entry \"foo\" not found in the data map in expression {foo.surname} in template foo.html on line 1",
                 RestAssured.get("test-foo").then().statusCode(200).extract().body().asString());
         assertEquals(
-                "Property \"name\" not found on the base object \"java.lang.String\" in expression {bar.name} in template bar on line 1",
+                "Property \"name\" not found on the base object \"java.lang.String\" in expression {bar.name} in template bar.html on line 1",
                 RestAssured.get("test-bar").then().statusCode(200).extract().body().asString());
     }
 
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/inject/InjectNamespaceResolverTest.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/inject/InjectNamespaceResolverTest.java
index e06cd09c13a1b..5e7ca7bb96d2c 100644
--- a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/inject/InjectNamespaceResolverTest.java
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/inject/InjectNamespaceResolverTest.java
@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.LongAdder;
 
 import javax.annotation.PreDestroy;
@@ -34,24 +35,30 @@ public class InjectNamespaceResolverTest {
 
     @Test
     public void testInjection() {
-        assertEquals("pong != simple and pong != simple", foo.render());
-        assertEquals(2, SimpleBean.DESTROYS.longValue());
+        assertEquals("pong != simple1 and pong != simple1", foo.render());
+        assertEquals(1, SimpleBean.DESTROYS.longValue());
 
         // Test the convenient Qute class
         // By default, the content type is plain text
-        assertEquals("pong::<br>", Qute.fmt("{cdi:hello.ping}::{}", "<br>"));
+        assertEquals("pong::simple2::simple2::<br>",
+                Qute.fmt("{cdi:hello.ping}::{cdi:simple.ping}::{inject:simple.ping}::{}", "<br>"));
         assertEquals("pong::&lt;br&gt;",
                 Qute.fmt("{cdi:hello.ping}::{newLine}").contentType("text/html").data("newLine", "<br>").render());
+        assertEquals(2, SimpleBean.DESTROYS.longValue());
     }
 
     @Named("simple")
     @Dependent
     public static class SimpleBean {
 
+        static final AtomicInteger COUNTER = new AtomicInteger();
+
         static final LongAdder DESTROYS = new LongAdder();
 
+        private final int id = COUNTER.incrementAndGet();
+
         public String ping() {
-            return "simple";
+            return "simple" + id;
         }
 
         @PreDestroy
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/EngineProducer.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/EngineProducer.java
index ea5bbc2e64752..d5ba946c79870 100644
--- a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/EngineProducer.java
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/EngineProducer.java
@@ -7,13 +7,19 @@
 import java.net.URL;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
-import java.util.function.Function;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.regex.Pattern;
 
 import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.Dependent;
 import javax.enterprise.event.Event;
 import javax.enterprise.event.Observes;
 import javax.enterprise.inject.Produces;
@@ -23,17 +29,22 @@
 import org.jboss.logging.Logger;
 
 import io.quarkus.arc.Arc;
+import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.InjectableBean;
 import io.quarkus.arc.InstanceHandle;
 import io.quarkus.qute.Engine;
 import io.quarkus.qute.EngineBuilder;
 import io.quarkus.qute.EvalContext;
+import io.quarkus.qute.Expression;
 import io.quarkus.qute.HtmlEscaper;
 import io.quarkus.qute.NamespaceResolver;
 import io.quarkus.qute.Qute;
 import io.quarkus.qute.ReflectionValueResolver;
 import io.quarkus.qute.Resolver;
 import io.quarkus.qute.Results;
+import io.quarkus.qute.Template;
 import io.quarkus.qute.TemplateInstance;
+import io.quarkus.qute.TemplateInstance.Initializer;
 import io.quarkus.qute.TemplateLocator.TemplateLocation;
 import io.quarkus.qute.UserTagSectionHelper;
 import io.quarkus.qute.ValueResolver;
@@ -51,6 +62,7 @@ public class EngineProducer {
 
     public static final String INJECT_NAMESPACE = "inject";
     public static final String CDI_NAMESPACE = "cdi";
+    public static final String DEPENDENT_INSTANCES = "q_dep_inst";
 
     private static final String TAGS = "tags/";
 
@@ -65,6 +77,7 @@ public class EngineProducer {
     private final Pattern templatePathExclude;
     private final Locale defaultLocale;
     private final Charset defaultCharset;
+    private final ArcContainer container;
 
     public EngineProducer(QuteContext context, QuteConfig config, QuteRuntimeConfig runtimeConfig,
             Event<EngineBuilder> builderReady, Event<Engine> engineReady, ContentTypes contentTypes, LaunchMode launchMode,
@@ -77,6 +90,7 @@ public EngineProducer(QuteContext context, QuteConfig config, QuteRuntimeConfig
         this.templatePathExclude = config.templatePathExclude;
         this.defaultLocale = locales.defaultLocale;
         this.defaultCharset = config.defaultCharset;
+        this.container = Arc.container();
 
         LOGGER.debugf("Initializing Qute [templates: %s, tags: %s, resolvers: %s", context.getTemplatePaths(), tags,
                 context.getResolverClasses());
@@ -146,17 +160,8 @@ public EngineProducer(QuteContext context, QuteConfig config, QuteRuntimeConfig
         builderReady.fire(builder);
 
         // Resolve @Named beans
-        Function<EvalContext, Object> cdiFun = new Function<EvalContext, Object>() {
-
-            @Override
-            public Object apply(EvalContext ctx) {
-                try (InstanceHandle<Object> bean = Arc.container().instance(ctx.getName())) {
-                    return bean.isAvailable() ? bean.get() : Results.NotFound.from(ctx);
-                }
-            }
-        };
-        builder.addNamespaceResolver(NamespaceResolver.builder(INJECT_NAMESPACE).resolve(cdiFun).build());
-        builder.addNamespaceResolver(NamespaceResolver.builder(CDI_NAMESPACE).resolve(cdiFun).build());
+        builder.addNamespaceResolver(NamespaceResolver.builder(INJECT_NAMESPACE).resolve(this::resolveInject).build());
+        builder.addNamespaceResolver(NamespaceResolver.builder(CDI_NAMESPACE).resolve(this::resolveInject).build());
 
         // Add generated resolvers
         for (String resolverClass : context.getResolverClasses()) {
@@ -187,15 +192,70 @@ public Object apply(EvalContext ctx) {
             builder.addTemplateInstanceInitializer(createInitializer(initializerClass));
         }
 
+        // Add a special initializer for templates that contain a inject/cdi namespace expressions
+        Map<String, Boolean> discoveredInjectTemplates = new HashMap<>();
+        builder.addTemplateInstanceInitializer(new Initializer() {
+
+            @Override
+            public void accept(TemplateInstance instance) {
+                Boolean hasInject = discoveredInjectTemplates.get(instance.getTemplate().getGeneratedId());
+                if (hasInject == null) {
+                    hasInject = hasInjectExpression(instance.getTemplate());
+                }
+                if (hasInject) {
+                    // Add dependent beans map if the template contains a cdi namespace expression
+                    instance.setAttribute(DEPENDENT_INSTANCES, new ConcurrentHashMap<>());
+                    // Add a close action to destroy all dependent beans
+                    instance.onRendered(new Runnable() {
+                        @Override
+                        public void run() {
+                            Object dependentInstances = instance.getAttribute(EngineProducer.DEPENDENT_INSTANCES);
+                            if (dependentInstances != null) {
+                                @SuppressWarnings("unchecked")
+                                ConcurrentMap<String, InstanceHandle<?>> existing = (ConcurrentMap<String, InstanceHandle<?>>) dependentInstances;
+                                if (!existing.isEmpty()) {
+                                    for (InstanceHandle<?> handle : existing.values()) {
+                                        handle.close();
+                                    }
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        });
+
         builder.timeout(runtimeConfig.timeout);
         builder.useAsyncTimeout(runtimeConfig.useAsyncTimeout);
 
         engine = builder.build();
 
-        // Load discovered templates
+        // Load discovered template files
+        Map<String, List<Template>> discovered = new HashMap<>();
         for (String path : context.getTemplatePaths()) {
-            engine.getTemplate(path);
+            Template template = engine.getTemplate(path);
+            if (template != null) {
+                for (String suffix : config.suffixes) {
+                    if (path.endsWith(suffix)) {
+                        String pathNoSuffix = path.substring(0, path.length() - (suffix.length() + 1));
+                        List<Template> templates = discovered.get(pathNoSuffix);
+                        if (templates == null) {
+                            templates = new ArrayList<>();
+                            discovered.put(pathNoSuffix, templates);
+                        }
+                        templates.add(template);
+                        break;
+                    }
+                }
+                discoveredInjectTemplates.put(template.getGeneratedId(), hasInjectExpression(template));
+            }
+        }
+        // If it's a default suffix then register a path without suffix as well
+        // hello.html -> hello, hello.html
+        for (Entry<String, List<Template>> e : discovered.entrySet()) {
+            processDefaultTemplate(e.getKey(), e.getValue(), config, engine);
         }
+
         engineReady.fire(engine);
 
         // Set the engine instance
@@ -291,6 +351,66 @@ Variant createVariant(String path) {
         return new Variant(defaultLocale, defaultCharset, contentType);
     }
 
+    private Object resolveInject(EvalContext ctx) {
+        InjectableBean<?> bean = container.namedBean(ctx.getName());
+        if (bean != null) {
+            if (bean.getScope().equals(Dependent.class)) {
+                // Dependent beans are shared across all expressions in a template for a single rendering operation
+                Object dependentInstances = ctx.getAttribute(EngineProducer.DEPENDENT_INSTANCES);
+                if (dependentInstances != null) {
+                    @SuppressWarnings("unchecked")
+                    ConcurrentMap<String, InstanceHandle<?>> existing = (ConcurrentMap<String, InstanceHandle<?>>) dependentInstances;
+                    return existing.computeIfAbsent(ctx.getName(), name -> container.instance(bean)).get();
+                }
+            }
+            return container.instance(bean).get();
+        }
+        return Results.NotFound.from(ctx);
+    }
+
+    private boolean hasInjectExpression(Template template) {
+        for (Expression expression : template.getExpressions()) {
+            if (isInjectExpression(expression)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isInjectExpression(Expression expression) {
+        String namespace = expression.getNamespace();
+        if (namespace != null && (CDI_NAMESPACE.equals(namespace) || INJECT_NAMESPACE.equals(namespace))) {
+            return true;
+        }
+        for (Expression.Part part : expression.getParts()) {
+            if (part.isVirtualMethod()) {
+                for (Expression param : part.asVirtualMethod().getParameters()) {
+                    if (param.isLiteral()) {
+                        continue;
+                    }
+                    if (isInjectExpression(param)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private void processDefaultTemplate(String path, List<Template> templates, QuteConfig config, Engine engine) {
+        if (engine.isTemplateLoaded(path)) {
+            return;
+        }
+        for (String suffix : config.suffixes) {
+            for (Template template : templates) {
+                if (template.getId().endsWith(suffix)) {
+                    engine.putTemplate(path, template);
+                    return;
+                }
+            }
+        }
+    }
+
     static class ResourceTemplateLocation implements TemplateLocation {
 
         private final URL resource;
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
index 0eafdc5715304..54fdfcbc19c14 100644
--- a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
@@ -127,6 +127,11 @@ public Optional<Variant> getVariant() {
             throw new UnsupportedOperationException("Injected templates do not support getVariant()");
         }
 
+        @Override
+        public String getId() {
+            throw new UnsupportedOperationException("Injected templates do not support getId()");
+        }
+
         @Override
         public String toString() {
             return "Injectable template [path=" + path + "]";
@@ -170,6 +175,11 @@ protected Engine engine() {
                 return engine;
             }
 
+            @Override
+            public Template getTemplate() {
+                return template();
+            }
+
             private TemplateInstance templateInstance() {
                 TemplateInstance instance = template().instance();
                 if (dataMap != null) {
@@ -180,6 +190,9 @@ private TemplateInstance templateInstance() {
                 if (!attributes.isEmpty()) {
                     attributes.forEach(instance::setAttribute);
                 }
+                if (!renderedActions.isEmpty()) {
+                    renderedActions.forEach(instance::onRendered);
+                }
                 return instance;
             }
 
diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java
index 482b843c80cc9..89ea7bc77e229 100644
--- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java
+++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanGenerator.java
@@ -219,7 +219,7 @@ Collection<Resource> generateSyntheticBean(BeanInfo bean) {
 
         implementGetIdentifier(bean, beanCreator);
         implementSupplierGet(beanCreator);
-        if (!bean.hasDefaultDestroy()) {
+        if (bean.hasDestroyLogic()) {
             implementDestroy(bean, beanCreator, providerType, Collections.emptyMap(), isApplicationClass, baseName);
         }
         implementCreate(classOutput, beanCreator, bean, providerType, baseName,
@@ -308,7 +308,7 @@ Collection<Resource> generateClassBean(BeanInfo bean, ClassInfo beanClass) {
 
         implementGetIdentifier(bean, beanCreator);
         implementSupplierGet(beanCreator);
-        if (!bean.hasDefaultDestroy()) {
+        if (bean.hasDestroyLogic()) {
             implementDestroy(bean, beanCreator, providerType, injectionPointToProviderSupplierField, isApplicationClass,
                     baseName);
         }
@@ -412,7 +412,7 @@ Collection<Resource> generateProducerMethodBean(BeanInfo bean, MethodInfo produc
 
         implementGetIdentifier(bean, beanCreator);
         implementSupplierGet(beanCreator);
-        if (!bean.hasDefaultDestroy()) {
+        if (bean.hasDestroyLogic()) {
             implementDestroy(bean, beanCreator, providerType, injectionPointToProviderField, isApplicationClass, baseName);
         }
         implementCreate(classOutput, beanCreator, bean, providerType, baseName,
@@ -501,7 +501,7 @@ Collection<Resource> generateProducerFieldBean(BeanInfo bean, FieldInfo producer
 
         implementGetIdentifier(bean, beanCreator);
         implementSupplierGet(beanCreator);
-        if (!bean.hasDefaultDestroy()) {
+        if (bean.hasDestroyLogic()) {
             implementDestroy(bean, beanCreator, providerType, null, isApplicationClass, baseName);
         }
         implementCreate(classOutput, beanCreator, bean, providerType, baseName,
diff --git a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanInfo.java b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanInfo.java
index e3ca6cad3eaf3..981c512edb3f5 100644
--- a/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanInfo.java
+++ b/independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/BeanInfo.java
@@ -337,17 +337,22 @@ boolean isSubclassRequired() {
                 || lifecycleInterceptors.containsKey(InterceptionType.PRE_DESTROY);
     }
 
-    boolean hasDefaultDestroy() {
-        if (isInterceptor()) {
-            return true;
+    /**
+     *
+     * @return {@code true} if the bean requires some customized destroy logic
+     */
+    public boolean hasDestroyLogic() {
+        if (isInterceptor() || isDecorator()) {
+            return false;
         }
-        if (isClassBean()) {
-            return getLifecycleInterceptors(InterceptionType.PRE_DESTROY).isEmpty()
-                    && Beans.getCallbacks(target.get().asClass(), DotNames.PRE_DESTROY, beanDeployment.getBeanArchiveIndex())
-                            .isEmpty();
-        } else {
-            return disposer == null && destroyerConsumer == null;
+        if (disposer != null || destroyerConsumer != null) {
+            // producer with disposer or custom bean with destruction logic
+            return true;
         }
+        // test class bean with @PreDestroy interceptor or callback
+        return isClassBean() && (!getLifecycleInterceptors(InterceptionType.PRE_DESTROY).isEmpty()
+                || !Beans.getCallbacks(target.get().asClass(), DotNames.PRE_DESTROY, beanDeployment.getBeanArchiveIndex())
+                        .isEmpty());
     }
 
     public boolean isForceApplicationClass() {
diff --git a/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcContainer.java b/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcContainer.java
index a804b01e5e547..5979a5bae573c 100644
--- a/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcContainer.java
+++ b/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/ArcContainer.java
@@ -150,6 +150,17 @@ public interface ArcContainer {
      */
     <T> InjectableBean<T> bean(String beanIdentifier);
 
+    /**
+     * Note that ambiguous names are detected at build time. Therefore, unlike
+     * {@link javax.enterprise.inject.spi.BeanManager.getBeans(String)} this method either returns a resolved bean or
+     * {@code null} if no bean matches.
+     *
+     * @param name
+     * @return an injectable bean with the given name or null
+     * @see InjectableBean#getName()
+     */
+    InjectableBean<?> namedBean(String name);
+
     /**
      * This method never throws {@link ContextNotActiveException}.
      *
diff --git a/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/ArcContainerImpl.java b/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/ArcContainerImpl.java
index d5dd8f235f6ca..3f80c908bc6d6 100644
--- a/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/ArcContainerImpl.java
+++ b/independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/ArcContainerImpl.java
@@ -305,6 +305,13 @@ public <T> InjectableBean<T> bean(String beanIdentifier) {
         return (InjectableBean<T>) beansById.getValue(beanIdentifier);
     }
 
+    @Override
+    public InjectableBean<?> namedBean(String name) {
+        Objects.requireNonNull(name);
+        Set<InjectableBean<?>> found = beansByName.getValue(name);
+        return found.size() == 1 ? found.iterator().next() : null;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public <T> InstanceHandle<T> instance(String name) {
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/Engine.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/Engine.java
index f45a57f5b5518..4ba6fd6598733 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/Engine.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/Engine.java
@@ -92,6 +92,14 @@ default Template parse(String content, Variant variant) {
      */
     public Template getTemplate(String id);
 
+    /**
+     * Note that template locators are not used in this method.
+     *
+     * @param id
+     * @return {@code true} if a template with the given identifier is loaded, {@code false} otherwise
+     */
+    public boolean isTemplateLoaded(String id);
+
     /**
      * Removes all templates from the cache.
      */
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/EngineImpl.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/EngineImpl.java
index 49fb99e6ceede..13d187f5508bb 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/EngineImpl.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/EngineImpl.java
@@ -121,6 +121,11 @@ public Template getTemplate(String id) {
         return templates.computeIfAbsent(id, this::load);
     }
 
+    @Override
+    public boolean isTemplateLoaded(String id) {
+        return templates.containsKey(id);
+    }
+
     @Override
     public void clearTemplates() {
         templates.clear();
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/Template.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/Template.java
index 8aebd0a5d683f..d9768c59a4205 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/Template.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/Template.java
@@ -127,6 +127,15 @@ default String render() {
      */
     String getGeneratedId();
 
+    /**
+     * An identifier used to obtain the template from the engine.
+     *
+     * @return the identifier
+     * @see Engine#getTemplate(String)
+     * @see Engine#parse(String, Variant, String)
+     */
+    String getId();
+
     /**
      *
      * @return the template variant
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateImpl.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateImpl.java
index 77eff8ae548bf..9d894675f678c 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateImpl.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateImpl.java
@@ -11,9 +11,12 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;
+import org.jboss.logging.Logger;
 
 class TemplateImpl implements Template {
 
+    private static final Logger LOG = Logger.getLogger(TemplateImpl.class);
+
     private final String templateId;
     private final String generatedId;
     private final EngineImpl engine;
@@ -49,6 +52,11 @@ public String getGeneratedId() {
         return generatedId;
     }
 
+    @Override
+    public String getId() {
+        return templateId;
+    }
+
     @Override
     public Optional<Variant> getVariant() {
         return variant;
@@ -159,12 +167,28 @@ private CompletionStage<Void> renderData(Object data, Consumer<String> consumer)
                         result.complete(null);
                     } catch (Throwable e) {
                         result.completeExceptionally(e);
+                    } finally {
+                        if (!renderedActions.isEmpty()) {
+                            for (Runnable action : renderedActions) {
+                                try {
+                                    action.run();
+                                } catch (Throwable e) {
+                                    LOG.error("Unable to perform an action when rendering finished", e);
+                                }
+                            }
+                        }
+
                     }
                 }
             });
             return result;
         }
 
+        @Override
+        public Template getTemplate() {
+            return TemplateImpl.this;
+        }
+
         @Override
         public String toString() {
             return "Instance of " + TemplateImpl.this.toString();
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstance.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstance.java
index 6b6ec5913cb5d..d046210465694 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstance.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstance.java
@@ -113,6 +113,20 @@ public interface TemplateInstance {
      */
     long getTimeout();
 
+    /**
+     *
+     * @return the original template
+     */
+    Template getTemplate();
+
+    /**
+     * Register an action that is performed after the rendering is finished.
+     *
+     * @param action
+     * @return self
+     */
+    TemplateInstance onRendered(Runnable action);
+
     /**
      * This component can be used to initialize a template instance, i.e. the data and attributes.
      *
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstanceBase.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstanceBase.java
index f974f9f18c338..0a90ebec1279c 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstanceBase.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateInstanceBase.java
@@ -1,7 +1,9 @@
 package io.quarkus.qute;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import org.jboss.logging.Logger;
 
@@ -15,9 +17,11 @@ public abstract class TemplateInstanceBase implements TemplateInstance {
     protected Object data;
     protected Map<String, Object> dataMap;
     protected final Map<String, Object> attributes;
+    protected final List<Runnable> renderedActions;
 
     public TemplateInstanceBase() {
         this.attributes = new HashMap<>();
+        this.renderedActions = new ArrayList<>();
     }
 
     @Override
@@ -49,18 +53,12 @@ public Object getAttribute(String key) {
         return attributes.get(key);
     }
 
-    protected Object data() {
-        if (data != null) {
-            return data;
-        }
-        if (dataMap != null) {
-            return Mapper.wrap(dataMap);
-        }
-        return EMPTY_DATA_MAP;
+    @Override
+    public TemplateInstance onRendered(Runnable action) {
+        renderedActions.add(action);
+        return this;
     }
 
-    protected abstract Engine engine();
-
     @Override
     public long getTimeout() {
         Object t = getAttribute(TemplateInstance.TIMEOUT);
@@ -78,4 +76,16 @@ public long getTimeout() {
         return engine().getTimeout();
     }
 
+    protected Object data() {
+        if (data != null) {
+            return data;
+        }
+        if (dataMap != null) {
+            return Mapper.wrap(dataMap);
+        }
+        return EMPTY_DATA_MAP;
+    }
+
+    protected abstract Engine engine();
+
 }
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceInitializerTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceInitializerTest.java
deleted file mode 100644
index ddbb1815226bb..0000000000000
--- a/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceInitializerTest.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package io.quarkus.qute;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Test;
-
-public class TemplateInstanceInitializerTest {
-
-    @Test
-    public void testInitializer() {
-        Engine engine = Engine.builder()
-                .addDefaults()
-                .addTemplateInstanceInitializer(instance -> instance.data("foo", "bar").setAttribute("alpha", Boolean.TRUE))
-                .build();
-
-        Template hello = engine.parse("Hello {foo}!");
-        TemplateInstance instance = hello.instance();
-        assertEquals(Boolean.TRUE, instance.getAttribute("alpha"));
-        assertEquals("Hello bar!", instance.render());
-        instance.data("foo", "baz");
-        assertEquals("Hello baz!", instance.render());
-    }
-
-}
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceTest.java
new file mode 100644
index 0000000000000..6355eb07a39a3
--- /dev/null
+++ b/independent-projects/qute/core/src/test/java/io/quarkus/qute/TemplateInstanceTest.java
@@ -0,0 +1,43 @@
+package io.quarkus.qute;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+
+public class TemplateInstanceTest {
+
+    @Test
+    public void testInitializer() {
+        Engine engine = Engine.builder()
+                .addDefaults()
+                .addTemplateInstanceInitializer(instance -> instance.data("foo", "bar").setAttribute("alpha", Boolean.TRUE))
+                .build();
+
+        Template hello = engine.parse("Hello {foo}!");
+        TemplateInstance instance = hello.instance();
+        assertEquals(Boolean.TRUE, instance.getAttribute("alpha"));
+        assertEquals("Hello bar!", instance.render());
+        instance.data("foo", "baz");
+        assertEquals("Hello baz!", instance.render());
+    }
+
+    @Test
+    public void testRendered() {
+        Engine engine = Engine.builder().addDefaults().build();
+        Template hello = engine.parse("Hello {foo}!");
+        AtomicBoolean rendered = new AtomicBoolean();
+        TemplateInstance instance = hello.instance().data("foo", "baz").onRendered(() -> rendered.set(true));
+        assertEquals("Hello baz!", instance.render());
+        assertTrue(rendered.get());
+    }
+
+    @Test
+    public void testGetTemplate() {
+        Engine engine = Engine.builder().addDefaults().build();
+        Template hello = engine.parse("Hello {foo}!");
+        String generatedId = hello.getGeneratedId();
+        assertEquals(generatedId, hello.instance().getTemplate().getGeneratedId());
+    }
+}