diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 932769c..6cbc1b9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -31,8 +31,8 @@ jobs:
       - name: Install dependencies
         run: composer install
       - name: Code Style
-        run: vendor/bin/php-cs-fixer check
+        run: composer cs
       - name: PHPStan
-        run: vendor/bin/phpstan
+        run: composer lint
       - name: PHPUnit
-        run: vendor/bin/phpunit
+        run: composer test
diff --git a/composer.json b/composer.json
index 515c648..cd0f6b4 100644
--- a/composer.json
+++ b/composer.json
@@ -45,5 +45,15 @@
         "phpunit/phpunit": "^11",
         "bnf/phpstan-psr-container": "^1.0",
         "friendsofphp/php-cs-fixer": "^3.87"
+    },
+    "scripts": {
+      "cs": "@phpcs:check",
+      "phpcs": "@phpcs:check",
+      "phpcs:check": "vendor/bin/php-cs-fixer check --diff --ansi",
+      "phpcs:fix": "vendor/bin/php-cs-fixer fix",
+      "lint": "@phpstan",
+      "phpstan": "vendor/bin/phpstan",
+      "test": "@phpunit",
+      "phpunit": "vendor/bin/phpunit"
     }
 }
diff --git a/src/Http/Serializer/HasStatusCode.php b/src/Http/Serializer/HasStatusCode.php
new file mode 100644
index 0000000..7cb7690
--- /dev/null
+++ b/src/Http/Serializer/HasStatusCode.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+interface HasStatusCode {
+    public function getStatusCode(): int;
+}
diff --git a/src/Http/Serializer/Json.php b/src/Http/Serializer/Json.php
new file mode 100644
index 0000000..78bc0e3
--- /dev/null
+++ b/src/Http/Serializer/Json.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+final readonly class Json {
+}
diff --git a/src/Http/Serializer/JsonResponse.php b/src/Http/Serializer/JsonResponse.php
new file mode 100644
index 0000000..7113d1e
--- /dev/null
+++ b/src/Http/Serializer/JsonResponse.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+use Fig\Http\Message\StatusCodeInterface;
+use JsonSerializable;
+
+#[Json]
+final readonly class JsonResponse implements HasStatusCode, JsonSerializable {
+    public static function of(mixed $data, int $statusCode = StatusCodeInterface::STATUS_OK): self {
+        return new self($data, $statusCode);
+    }
+
+    private function __construct(private mixed $data, private int $statusCode) {
+    }
+
+    public function jsonSerialize(): mixed {
+        return $this->data;
+    }
+
+    public function getStatusCode(): int {
+        return $this->statusCode;
+    }
+}
diff --git a/src/Http/Serializer/JsonSerializingInvoker.php b/src/Http/Serializer/JsonSerializingInvoker.php
new file mode 100644
index 0000000..55df474
--- /dev/null
+++ b/src/Http/Serializer/JsonSerializingInvoker.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+use Fig\Http\Message\StatusCodeInterface;
+use Invoker\Exception\InvocationException;
+use Invoker\Exception\NotCallableException;
+use Invoker\Exception\NotEnoughParametersException;
+use Invoker\InvokerInterface;
+use JsonException;
+use JsonSerializable;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use ReflectionClass;
+
+final readonly class JsonSerializingInvoker implements InvokerInterface {
+    public function __construct(
+        private InvokerInterface $inner,
+        private JsonSerializingInvokerOptions $options,
+        private ResponseFactoryInterface $responseFactory,
+        private StreamFactoryInterface $streamFactory,
+    ) {
+    }
+
+    /**
+     * @param callable $callable
+     * @param array<mixed> $parameters
+     * @throws InvocationException
+     * @throws NotCallableException
+     * @throws NotEnoughParametersException
+     * @throws JsonException
+     */
+    public function call($callable, array $parameters = []): mixed {
+        $result = $this->inner->call($callable, $parameters);
+
+        if ($result instanceof ResponseInterface) {
+            return $result;
+        }
+
+        if (false === $this->shouldConvert($result)) {
+            return $result;
+        }
+
+        $statusCode = StatusCodeInterface::STATUS_OK;
+
+        if ($result instanceof HasStatusCode) {
+            $statusCode = $result->getStatusCode();
+        }
+
+        return $this->responseFactory->createResponse($statusCode)
+            ->withHeader('Content-Type', 'application/json')
+            ->withBody(
+                $this->streamFactory->createStream(
+                    json_encode($result, JSON_THROW_ON_ERROR),
+                ),
+            );
+    }
+
+    private function shouldConvert(mixed $result): bool {
+        if (is_resource($result)) {
+            return false;
+        }
+
+        if (false === is_object($result)) {
+            return $this->options->serializeSimpleTypes;
+        }
+
+        if ($this->options->serializeObjects) {
+            return true;
+        }
+
+        $reflection = new ReflectionClass($result);
+
+        if (0 !== count($reflection->getAttributes(Json::class))) {
+            return true;
+        }
+
+        if ($result instanceof JsonSerializable) {
+            return $this->options->serializeJsonSerializable;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Http/Serializer/JsonSerializingInvokerOptions.php b/src/Http/Serializer/JsonSerializingInvokerOptions.php
new file mode 100644
index 0000000..f551756
--- /dev/null
+++ b/src/Http/Serializer/JsonSerializingInvokerOptions.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+final readonly class JsonSerializingInvokerOptions {
+    public static function simpleTypes(): self {
+        return new self(
+            serializeSimpleTypes: true,
+            serializeJsonSerializable: false,
+            serializeObjects: false,
+        );
+    }
+
+    public static function onlyExplicitlyMarked(): self {
+        return new self(
+            serializeSimpleTypes: false,
+            serializeJsonSerializable: false,
+            serializeObjects: false,
+        );
+    }
+
+    public static function all(): self {
+        return new self(
+            serializeSimpleTypes: true,
+            serializeJsonSerializable: true,
+            serializeObjects: true,
+        );
+    }
+
+    public function __construct(
+        public bool $serializeSimpleTypes = true,
+        public bool $serializeJsonSerializable = true,
+        public bool $serializeObjects = true,
+    ) {
+    }
+}
diff --git a/src/ServiceFactory/SlimServiceFactory.php b/src/ServiceFactory/SlimServiceFactory.php
index edc2c63..2e6b82e 100644
--- a/src/ServiceFactory/SlimServiceFactory.php
+++ b/src/ServiceFactory/SlimServiceFactory.php
@@ -7,6 +7,7 @@
 use DI\Bridge\Slim\Bridge;
 use DI\Bridge\Slim\ControllerInvoker;
 use Invoker\Invoker;
+use Invoker\InvokerInterface;
 use Invoker\ParameterResolver\AssociativeArrayResolver;
 use Invoker\ParameterResolver\Container\TypeHintContainerResolver;
 use Invoker\ParameterResolver\DefaultValueResolver;
@@ -14,11 +15,13 @@
 use Invoker\ParameterResolver\TypeHintResolver;
 use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
 use RuntimeException;
 use Slim\App;
 use Slim\Interfaces\CallableResolverInterface;
 use Slim\Middleware\ErrorMiddleware;
 use Slim\Psr7\Factory\ResponseFactory;
+use Slim\Psr7\Factory\StreamFactory;
 use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
 use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
@@ -30,13 +33,17 @@
 use Symfony\Component\Serializer\Serializer;
 use Symfony\Component\Serializer\SerializerInterface;
 use WonderNetwork\SlimKernel\Http\Serializer\DeserializeParameterResolver;
+use WonderNetwork\SlimKernel\Http\Serializer\JsonSerializingInvoker;
+use WonderNetwork\SlimKernel\Http\Serializer\JsonSerializingInvokerOptions;
 use WonderNetwork\SlimKernel\ServiceFactory;
 use WonderNetwork\SlimKernel\ServicesBuilder;
 use WonderNetwork\SlimKernel\SlimExtension\ErrorMiddlewareConfiguration;
+use function DI\autowire;
 use function DI\get;
 
 final class SlimServiceFactory implements ServiceFactory {
     public const string INPUT_DENORMALIZER = self::class.':input-denormalizer';
+    public const string INVOKER = self::class.':invoker';
 
     public function __invoke(ServicesBuilder $builder): iterable {
         yield Serializer::class => static fn () => new Serializer([
@@ -56,7 +63,7 @@ public function __invoke(ServicesBuilder $builder): iterable {
         yield SerializerInterface::class => get(Serializer::class);
         yield self::INPUT_DENORMALIZER => get(DenormalizerInterface::class);
 
-        yield ControllerInvoker::class => static function (ContainerInterface $container) {
+        yield Invoker::class => static function (ContainerInterface $container) {
             $serializer = $container->get(SlimServiceFactory::INPUT_DENORMALIZER);
 
             if (false === $serializer instanceof DenormalizerInterface) {
@@ -70,21 +77,45 @@ public function __invoke(ServicesBuilder $builder): iterable {
                 );
             }
 
-            return new ControllerInvoker(
-                new Invoker(
-                    new ResolverChain([
-                        new TypeHintResolver(),
-                        new AssociativeArrayResolver(),
-                        new DeserializeParameterResolver($serializer),
-                        new TypeHintContainerResolver($container),
-                        new DefaultValueResolver(),
-                    ]),
-                    $container,
-                ),
+            return new Invoker(
+                new ResolverChain([
+                    new TypeHintResolver(),
+                    new AssociativeArrayResolver(),
+                    new DeserializeParameterResolver($serializer),
+                    new TypeHintContainerResolver($container),
+                    new DefaultValueResolver(),
+                ]),
+                $container,
             );
         };
 
+        yield JsonSerializingInvoker::class => autowire()->constructor(
+            get(Invoker::class),
+        );
+
+        yield self::INVOKER => get(JsonSerializingInvoker::class);
+
+        yield ControllerInvoker::class => static function (ContainerInterface $container) {
+            $invoker = $container->get(SlimServiceFactory::INVOKER);
+
+            if (false === $invoker instanceof InvokerInterface) {
+                throw new RuntimeException(
+                    sprintf(
+                        'Service registered under %s key is expected to implement %s interface, %s given',
+                        SlimServiceFactory::INVOKER,
+                        InvokerInterface::class,
+                        get_debug_type($invoker),
+                    ),
+                );
+            }
+
+            return new ControllerInvoker($invoker);
+        };
+
+        yield JsonSerializingInvokerOptions::class => static fn () => JsonSerializingInvokerOptions::onlyExplicitlyMarked();
+
         yield ResponseFactoryInterface::class => static fn () => new ResponseFactory();
+        yield StreamFactoryInterface::class => static fn () => new StreamFactory();
         yield ErrorMiddlewareConfiguration::class => static fn () => ErrorMiddlewareConfiguration::silent();
 
         yield ErrorMiddleware::class => static fn (
diff --git a/tests/Http/Serializer/EchoController.php b/tests/Http/Serializer/EchoController.php
index 7577e69..59de82c 100644
--- a/tests/Http/Serializer/EchoController.php
+++ b/tests/Http/Serializer/EchoController.php
@@ -4,20 +4,13 @@
 
 namespace WonderNetwork\SlimKernel\Http\Serializer;
 
-use Psr\Http\Message\ResponseInterface;
-use Slim\Psr7\Factory\StreamFactory;
-
 final readonly class EchoController {
     public function __invoke(
         #[Payload] SamplePostInput $post,
         #[Payload(source: PayloadSource::Get)] SampleGetInput $get,
-        ResponseInterface $response,
-    ): ResponseInterface {
-        $streamFactory = new StreamFactory();
+    ): JsonResponse {
         $payload = compact('post', 'get');
-        $json = json_encode($payload, JSON_THROW_ON_ERROR);
-        $body = $streamFactory->createStream($json);
 
-        return $response->withBody($body);
+        return JsonResponse::of($payload);
     }
 }
diff --git a/tests/Http/Serializer/JsonSerializingInvokerMother.php b/tests/Http/Serializer/JsonSerializingInvokerMother.php
new file mode 100644
index 0000000..a4d4f00
--- /dev/null
+++ b/tests/Http/Serializer/JsonSerializingInvokerMother.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+use Invoker\Invoker;
+use Slim\Factory\Psr17\SlimPsr17Factory;
+
+final readonly class JsonSerializingInvokerMother {
+    public static function all(): JsonSerializingInvoker {
+        return self::withOptions(JsonSerializingInvokerOptions::all());
+    }
+
+    public static function onlyMarked(): JsonSerializingInvoker {
+        return self::withOptions(JsonSerializingInvokerOptions::onlyExplicitlyMarked());
+    }
+
+    private static function withOptions(JsonSerializingInvokerOptions $options): JsonSerializingInvoker {
+        return new JsonSerializingInvoker(
+            inner: new Invoker(),
+            options: $options,
+            responseFactory: SlimPsr17Factory::getResponseFactory(),
+            streamFactory: SlimPsr17Factory::getStreamFactory(),
+        );
+    }
+}
diff --git a/tests/Http/Serializer/JsonSerializingInvokerTest.php b/tests/Http/Serializer/JsonSerializingInvokerTest.php
new file mode 100644
index 0000000..c2d1419
--- /dev/null
+++ b/tests/Http/Serializer/JsonSerializingInvokerTest.php
@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WonderNetwork\SlimKernel\Http\Serializer;
+
+use Fig\Http\Message\StatusCodeInterface;
+use JsonSerializable;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\ResponseInterface;
+use stdClass;
+
+final class JsonSerializingInvokerTest extends TestCase {
+    /**
+     * @return iterable<array{0:mixed}>
+     */
+    public static function dataSimpleTypes(): iterable {
+        yield [null];
+        yield [1];
+        yield [1.5];
+        yield ["hello"];
+        yield [['message' => 'Success']];
+    }
+
+    #[DataProvider('dataSimpleTypes')]
+    public function testSerializesSimpleTypes(mixed $result): void {
+        $sut = JsonSerializingInvokerMother::all();
+        $response = $sut->call(fn () => $result);
+        self::assertInstanceOf(ResponseInterface::class, $response);
+    }
+
+    #[DataProvider('dataSimpleTypes')]
+    public function testSkipsWhenSimpleTypesDisabled(mixed $result): void {
+        $sut = JsonSerializingInvokerMother::onlyMarked();
+
+        $response = $sut->call(fn () => $result);
+        self::assertSame($result, $response);
+    }
+
+    public function testSerializesJsonSerializable(): void {
+        $sut = JsonSerializingInvokerMother::all();
+
+        $object = new class () implements JsonSerializable {
+            public function jsonSerialize(): null {
+                return null;
+            }
+        };
+
+        $response = $sut->call(fn () => $object);
+
+        self::assertInstanceOf(ResponseInterface::class, $response);
+    }
+
+    public function testSkipsWhenJsonSerializableDisabled(): void {
+        $sut = JsonSerializingInvokerMother::onlyMarked();
+
+        $object = new class () implements JsonSerializable {
+            public function jsonSerialize(): null {
+                return null;
+            }
+        };
+        $response = $sut->call(fn () => $object);
+
+        self::assertSame($object, $response);
+    }
+
+    public function testSerializesObjects(): void {
+        $sut = JsonSerializingInvokerMother::all();
+
+        $response = $sut->call(fn () => new stdClass());
+
+        self::assertInstanceOf(ResponseInterface::class, $response);
+    }
+
+    public function testSkipsWhenObjectsDisabled(): void {
+        $sut = JsonSerializingInvokerMother::onlyMarked();
+
+        $object = new stdClass();
+        $response = $sut->call(fn () => $object);
+
+        self::assertSame($object, $response);
+    }
+
+    public function testSkipsOnResources(): void {
+        $sut = JsonSerializingInvokerMother::all();
+
+        $resource = fopen('php://temp', 'rb+');
+        $response = $sut->call(fn () => $resource);
+
+        self::assertSame($resource, $response);
+    }
+
+    public function testSerializesObjectsMarkedWithAttribute(): void {
+        $sut = JsonSerializingInvokerMother::onlyMarked();
+
+        $response = $sut->call(fn () => JsonResponse::of('whatever'));
+
+        self::assertInstanceOf(ResponseInterface::class, $response);
+    }
+
+    public function testSetsCustomStatusCode(): void {
+        $sut = JsonSerializingInvokerMother::all();
+
+        $response = $sut->call(fn () => JsonResponse::of(null, StatusCodeInterface::STATUS_ACCEPTED));
+
+        self::assertInstanceOf(ResponseInterface::class, $response);
+        self::assertSame(202, $response->getStatusCode());
+    }
+}
diff --git a/tests/Resources/App/app/services/services.php b/tests/Resources/App/app/services/services.php
index 17755d3..d838db3 100644
--- a/tests/Resources/App/app/services/services.php
+++ b/tests/Resources/App/app/services/services.php
@@ -3,11 +3,8 @@
 declare(strict_types=1);
 
 use Acme\HelloWorldController;
-use Psr\Http\Message\StreamFactoryInterface;
-use Slim\Psr7\Factory\StreamFactory;
 use function DI\autowire;
 
 return [
     HelloWorldController::class => autowire(),
-    StreamFactoryInterface::class => autowire(StreamFactory::class),
 ];
diff --git a/tests/Resources/App/src/HelloWorldController.php b/tests/Resources/App/src/HelloWorldController.php
index 6c33356..007b61f 100644
--- a/tests/Resources/App/src/HelloWorldController.php
+++ b/tests/Resources/App/src/HelloWorldController.php
@@ -8,11 +8,8 @@
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamFactoryInterface;
 
-final class HelloWorldController {
-    private StreamFactoryInterface $streamFactory;
-
-    public function __construct(StreamFactoryInterface $streamFactory) {
-        $this->streamFactory = $streamFactory;
+final readonly class HelloWorldController {
+    public function __construct(private StreamFactoryInterface $streamFactory) {
     }
 
     public function __invoke(
diff --git a/tests/Resources/ErrorMiddleware/src/CustomErrorMiddleware.php b/tests/Resources/ErrorMiddleware/src/CustomErrorMiddleware.php
index 7ff106b..5c77013 100644
--- a/tests/Resources/ErrorMiddleware/src/CustomErrorMiddleware.php
+++ b/tests/Resources/ErrorMiddleware/src/CustomErrorMiddleware.php
@@ -10,11 +10,8 @@
 use Psr\Http\Server\RequestHandlerInterface;
 use Throwable;
 
-final class CustomErrorMiddleware implements MiddlewareInterface {
-    private ErrorHandlingSpy $spy;
-
-    public function __construct(ErrorHandlingSpy $spy) {
-        $this->spy = $spy;
+final readonly class CustomErrorMiddleware implements MiddlewareInterface {
+    public function __construct(private ErrorHandlingSpy $spy) {
     }
 
     public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface {