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

Yazılım geliştirici · Sistem tasarımıPortföy / 01

Merhaba, ben bir yazılım geliştiriciyim.

Fikirleri koda, kodu çözüme dönüştürüyorum.

Karmaşık problemlere sade çözümler. Backend mimarisi, modern web teknolojileri ve yapay zekâ ile sürdürülebilir sistemler tasarlıyorum.

Projelerimi keşfet Beni tanıyın

yaklasim.ts

1const developer = {
2  mindset: 'problem solver',
3  focus: ['clean architecture',
4    'scalable systems',
5    'continuous learning'],
6  build: () => createImpact()
7};
8// Daha iyi bir çözüm her zaman var.

Mantık. Mimari. Etki.

Keşfetmeye devam et

C# / .NET / PYTHON / REACT / RUSTANALİZ → MİMARİ → KOD

Teknik odak / 01

Sadece kod değil, doğru mimari.

Diller & geliştirme

C#
Java
JavaScript
Python
Rust
ASP.NET Core
React

Backend & mimari

Clean Architecture
DDD
CQRS
SQL
Veritabanı tasarımı

Yapay zekâ & veri

Yapay zekâ
Makine öğrenmesi
Algoritmalar
Python

Yaklaşımım / 02

Önce problemi anla. Sonra çözümü tasarla.

İyi yazılımın yalnızca çalışması değil, anlaşılabilir ve geliştirilebilir olması gerektiğine inanıyorum...

Analitik düşünme
Temiz kod
Sürekli öğrenme

Birlikte düşünelim

Ürettiklerim / 03

Kodun gerçek dünyadaki karşılığı.

Yapay Zekâ · OCR · Otomasyon · Devam Ediyor · 31 Ekim 2026

AI Destekli Fatura Okuma

Faturalardaki bilgileri yapay zekâ ve OCR teknolojileriyle otomatik olarak çıkaran uygulama.

Python · FastAPI · React · TypeScript · 31 Ekim 2026

AI Destekli PDF Okuma ve Evrak Hazırlama

PDF belgelerini yapay zekâ ile analiz eden ve elde edilen bilgilerle evrak hazırlama süreçlerini kolaylaştıran uygulama.

Python · Machine Learning · OCR · AI · 31 Ekim 2026

Beton Analiz AI

Beton deney raporlarını yapay zekâ ve makine öğrenmesiyle analiz etmeye yönelik uygulama.

Not defteri / 04

Öğrenirken, paylaşırken.

Yazılım Mimarisi · Yapay Zekâ · Algoritmalar · Programlama · 31 Ekim 2026

Teknoloji Notları

Yazılım mimarisi, yapay zekâ, algoritmalar ve modern programlama teknolojileri üzerine teknik yazılar ve deneyimler.

İletişim / 05

İyi bir fikir, bir konuşmayla başlar.

Aklındaki fikri, problemi ya da projeyi kısaca yaz; birlikte bakalım.