1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

1// Application/Orders/CreateOrderHandler.cs

2public sealed class CreateOrderHandler

3 : IRequestHandler<CreateOrder, Result<OrderId>>

4{

5 public async Task<Result<OrderId>> Handle(CreateOrder cmd, CancellationToken ct)

6 {

7 var order = Order.Create(cmd.CustomerId, cmd.Lines);

8 await _repo.AddAsync(order, ct);

9 await _uow.CommitAsync(ct);

10 return Result.Ok(order.Id);

11 }

12}

13

14# inference/pipeline.py

15def predict(model, batch):

16 features = normalize(batch)

17 scores = model(features)

18 return rank(scores, top_k=5)

19

20-- reports/latency.sql

21SELECT service, p95(duration_ms)

22FROM traces

23WHERE ts > now() - interval '1 day'

24ORDER BY 2 DESC;

25

26// domain/src/lib.rs

27pub trait Repository<T> {

28 fn find(&self, id: Id) -> Option<T>;

29 fn save(&mut self, item: T) -> Result<()>;

30}

31

32// ui/useOrders.ts

33export const useOrders = () =>

34 useQuery(['orders'], fetchOrders);

35

Cloud Computing · Automation · DevOps · API · 31 Ekim 2026

Kurumsal Bulut Sistemleri ve Otomasyonlar

Şirketlerin iş süreçlerine özel bulut sistemleri, merkezi yönetim altyapıları ve otomasyon çözümleri.

Çalışma alanı

Şirketlerin ihtiyaçlarına göre bulut üzerinde çalışan merkezi yazılım sistemleri tasarlıyor ve geliştiriyorum.

İş akışı otomasyonları, kullanıcı ve yetki yönetimi, merkezi veri yönetimi ve farklı sistemler arasında entegrasyonlar sağlayarak kurumsal süreçlerin dijitalleşmesine katkıda bulunuyorum.

Uygulamaların bulut sunuculara kurulumu, yapılandırılması ve yayına alınması süreçlerini de yürütüyorum.