💰 Explosive Financial Growth

• $2.98 Billion Revenue: Global in-app purchase revenue generated by short drama apps across 2025.
• 115% Year-Over-Year Increase: The third-fastest growth rate of any app category tracked by Sensor Tower. [2, 4]

⏱️ Overtaking Mobile Engagement

Data from Q4 2025 shows that daily usage of short drama leaders like ReelShort beats premium long-form streaming platforms on mobile devices in the U.S.: [2, 5]

• ReelShort: 35.7 minutes per day per user.
• Amazon Prime Video: 26.9 minutes per day.
• Netflix Mobile: 24.8 minutes per day.
• Disney+: 23.0 minutes per day. [2, 3]

📥 Surging App Downloads

• 733 Million Downloads: Total global installs driven by microdrama apps in Q4 2025 alone.
• 658 Million Downloads: Total global installs for traditional long-form streaming platforms in the same timeframe. [2]

The underlying analysis published by platforms like Filmustage notes that these numbers anchor production and pitching decisions for creators in 2026. Major legacy Hollywood entrants are actively building mobile-first vertical strategies to tap into this highly addictive, micro-payment-driven business model. [2, 6] If you’d like, I can:

• Explain the monetization models used by these apps
• Provide details on the top dominating apps in this space
• Break down the typical genres and formats of microdramas

[1] https://finance.yahoo.com [2] https://filmustage.com [3] https://omdia.tech.informa.com [4] https://www.media-marketing.com [5] https://deadline.com [6] https://www.youtube.com

Evet, bu veriler kesinlikle doğrudur ve bu sektörde gerçekten bu kadar büyük kazançlar bulunmaktadır. [1, 2] Görselde yer alan istatistikler, mobil pazar analiz şirketleri Sensor Tower ve Omdia tarafından yayınlanan resmi raporlara dayanmaktadır. Hatta güncel küresel pazar payı verileri incelendiğinde, bu dikey kısa dizi (microdrama) sektörünün toplam büyüklüğü (Çin içi pazar dahil) 11 milyar doları aşmış durumdadır. [1, 2, 3, 4] Bu kadar yüksek kazançların oluşmasının ardında yatan temel faktörler şunlardır:

🪙 Pahalı ve Agresif Para Kazanma Modeli

• Bölüm Başına Ödeme: Netflix gibi platformlara ayda sabit bir ücret ödersiniz. Short drama uygulamalarında (ReelShort, DramaBox vb.) ise ilk 5-10 bölüm ücretsizdir. Sonraki her bir dakikalık bölümü izlemek için “jeton” (coin) satın almanız gerekir. [1]
• Tuzak Kurgular: Diziler tam en heyecanlı yerinde (cliffhanger) bittiği için kullanıcılar fark etmeden ardı ardına jeton harcar. Bir dizinin tamamını (ortalama 60-90 bölüm) bitirmek bazen 50 ila 100 dolar arasında bir maliyete ulaşabilir. Bu da sinema biletinden veya aylık Netflix aboneliğinden çok daha pahalıdır.

🎬 Düşük Maliyet, Yüksek Kâr Marjı

• Ucuz Prodüksiyon: Hollywood yapımları milyonlarca dolar harcarken, bu dikey diziler Los Angeles veya Doğu Avrupa’da, amatör ya da yarı profesyonel oyuncularla, telefonların dikey formatına uygun olarak 150.000 – 250.000 gibi çok düşük bütçelerle, sadece birkaç günde çekilir.
• Hızlı Geri Dönüş: Yatırılan bütçe, agresif sosyal medya reklamları sayesinde birkaç hafta içinde katlanarak geri kazanılır. [1, 5]

📈 Devlerin Rekabeti (2026 Trendi)

Pazardaki bu devasa para akışı nedeniyle, 2026 yılı itibarıyla Disney (Disney Accelerator programı üzerinden), Amazon ve TikTok (Pine Drama) gibi dev şirketler de kendi dikey kısa dizi formatlarını ve yatırımlarını devreye sokarak bu milyar dolarlık pastadan pay almaya başlamıştır. [1, 5] Kısacası, insanların mobil cihazlardaki kısalan dikkat sürelerini ve “merak” duygusunu paraya çeviren bu sistem, şu an uygulama dünyasının en çok kazandıran iş modellerinden biridir. [2, 6]

[1] https://filmustage.com [2] https://www.media-marketing.com [3] https://deadline.com [4] https://www.mediapost.com [5] https://www.linkedin.com [6] https://asoworld.com

1. Frontend: SortableJS ile Menü Yönetimi

Önce CDN üzerinden gerekli kütüphaneyi HTML’ine ekle:

<script src="https://raw.githack.com/SortableJS/Sortable/master/Sortable.js"></script>

HTML Yapısı:

<ul id="menu-list" class="menu-container">
    <li data-id="1">Anasayfa</li>
    <li data-id="2">Hakkımızda
        <ul class="nested-menu">
            <li data-id="3">Ekibimiz</li>
        </ul>
    </li>
    <li data-id="4">İletişim</li>
</ul>

<button id="save-menu">Menüyü Kaydet</button>

JavaScript:

new Sortable(document.getElementById('menu-list'), {
    group: 'nested',
    animation: 150,
    fallbackOnBody: true,
    swapThreshold: 0.65
});

document.getElementById('save-menu').addEventListener('click', () => {
    // Tüm listeyi serialize et ve Go backend'e gönder
    const data = getOrder(document.getElementById('menu-list'));
    fetch('/api/menu/save', {
        method: 'POST',
        body: JSON.stringify(data),
        headers: {'Content-Type': 'application/json'}
    });
});

2. Backend: Go (Fiber) Skeleton

Veritabanında menüleri id, parent_id ve order sütunları ile tutman yeterlidir. Go tarafında gelen veriyi karşılayacak ve kaydedecek yapıyı kuralım.

Model (GORM):

type MenuItem struct {
    ID       uint   `json:"id"`
    ParentID uint   `json:"parent_id"`
    Title    string `json:"title"`
    Order    int    `json:"order"`
}

API Handler (Fiber):

package main

import (
    "github.com/gofiber/fiber/v2"
)

func main() {
    app := fiber.New()

    app.Post("/api/menu/save", func(c *fiber.Ctx) error {
        var menuItems []MenuItem
        if err := c.BodyParser(&menuItems); err != nil {
            return c.Status(400).JSON(fiber.Map{"error": "Geçersiz veri"})
        }

        // Veritabanı işlemi:
        // 1. Transaction başlat (db.Begin())
        // 2. Mevcut menüyü temizle veya update et
        // 3. Gelen yeni sıralamayı döngüyle veritabanına işle

        return c.JSON(fiber.Map{"status": "success"})
    })

    app.Listen(":3000")
}

Kritik İpuçları:

1. Serialization: SortableJS ile iç içe listeleri çekerken nested yapıyı korumak için sortable.toArray() yerine her li elemanının verisini (id ve parent) manuel olarak bir map içinde toplamanı öneririm.
2. Veritabanı: PostgreSQL kullanıyorsan, menüleri getirmek için WITH RECURSIVE sorgusunu bir “view” olarak tanımlarsan, Go tarafından menüyü çekmek tek bir satır sürer.
3. Güvenlik: Menü kaydetme endpoint’ine mutlaka bir Auth Middleware ekle ki herkes menüleri değiştiremesin.

Bu skeleton üzerinden ilerleyerek, sortable.toArray() fonksiyonunun döndürdüğü veriyi JSON olarak backend’e nasıl parse edeceğin konusunda bir örneğe ihtiyaç duyarsan detaylandırabilirim. Hangi veritabanı kütüphanesini (GORM, sqlx vb.) kullanıyorsun?

📁 Folder Structure

hexagonal-go/
├── go.mod
├── cmd/
│   └── api/
│       └── main.go
└── internal/
    ├── domain/
    │   └── order/
    │       ├── money.go
    │       ├── order.go
    │       ├── order_id.go
    │       ├── order_status.go
    │       └── repository.go
    ├── application/
    │   └── order_service.go
    └── adapters/
        ├── http/
        │   └── order_handler.go
        └── persistence/
            └── memory/
                └── order_repository.go

1) go.mod

module example.com/hexagonal-go

go 1.22

2) Domain Layer

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.go

package order

import "fmt"

type Money struct {
    Cents int64
}

func NewMoney(cents int64) (Money, error) {
    if cents < 0 {
        return Money{}, fmt.Errorf("money cannot be negative")
    }
    return Money{Cents: cents}, nil
}

func (m Money) Add(other Money) Money {
    return Money{Cents: m.Cents + other.Cents}
}

internal/domain/order/order.go

package order

import "fmt"

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice Money
}

type Order struct {
    id     OrderID
    items  []OrderItem
    status OrderStatus
}

func NewOrder(id OrderID) *Order {
    return &Order{
        id:     id,
        items:  make([]OrderItem, 0),
        status: OrderStatusCreated,
    }
}

func (o *Order) ID() OrderID {
    return o.id
}

func (o *Order) Status() OrderStatus {
    return o.status
}

func (o *Order) Items() []OrderItem {
    copied := make([]OrderItem, len(o.items))
    copy(copied, o.items)
    return copied
}

func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error {
    if o.status != OrderStatusCreated {
        return fmt.Errorf("order cannot be modified after completion")
    }
    if productID == "" {
        return fmt.Errorf("product id cannot be empty")
    }
    if quantity <= 0 {
        return fmt.Errorf("quantity must be greater than zero")
    }

    o.items = append(o.items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    })

    return nil
}

func (o *Order) Complete() error {
    if len(o.items) == 0 {
        return fmt.Errorf("order must have at least one item")
    }
    o.status = OrderStatusCompleted
    return nil
}

func (o *Order) Total() Money {
    total := Money{Cents: 0}
    for _, item := range o.items {
        total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)})
    }
    return total
}

internal/domain/order/repository.go

package order

import "context"

type Repository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id OrderID) (*Order, error)
}

3) Application Layer

internal/application/order_service.go

package application

import (
    "context"
    "fmt"
    "time"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderService struct {
    repo order.Repository
}

func NewOrderService(repo order.Repository) *OrderService {
    return &OrderService{repo: repo}
}

func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) {
    id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano()))
    newOrder := order.NewOrder(id)

    if err := s.repo.Save(ctx, newOrder); err != nil {
        return nil, err
    }

    return newOrder, nil
}

func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    price, err := order.NewMoney(priceCents)
    if err != nil {
        return nil, err
    }

    if err := o.AddItem(productID, quantity, price); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    if err := o.Complete(); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    return s.repo.FindByID(ctx, orderID)
}

4) Persistence Adapter (In-Memory)

internal/adapters/persistence/memory/order_repository.go

package memory

import (
    "context"
    "fmt"
    "sync"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderRepository struct {
    mu     sync.RWMutex
    orders map[order.OrderID]*order.Order
}

func NewOrderRepository() *OrderRepository {
    return &OrderRepository{
        orders: make(map[order.OrderID]*order.Order),
    }
}

func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error {
    r.mu.Lock()
    defer r.mu.Unlock()

    r.orders[o.ID()] = o
    return nil
}

func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    o, ok := r.orders[id]
    if !ok {
        return nil, fmt.Errorf("order not found: %s", id)
    }

    return o, nil
}

5) HTTP Adapter

internal/adapters/http/order_handler.go

package httpadapter

import (
    "encoding/json"
    "net/http"
    "strings"

    "example.com/hexagonal-go/internal/application"
    "example.com/hexagonal-go/internal/domain/order"
)

type OrderHandler struct {
    service *application.OrderService
}

func NewOrderHandler(service *application.OrderService) *OrderHandler {
    return &OrderHandler{service: service}
}

func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) {
    mux.HandleFunc("POST /orders", h.createOrder)
    mux.HandleFunc("GET /orders/", h.getOrder)
    mux.HandleFunc("POST /orders/{id}/items", h.addItem)
    mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder)
}

func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) {
    o, err := h.service.CreateOrder(r.Context())
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    respondJSON(w, http.StatusCreated, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.GetOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "items":  o.Items(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)

    var req struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
        PriceCents int64  `json:"price_cents"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid json", http.StatusBadRequest)
        return
    }

    o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func extractID(path string) string {
    parts := strings.Split(strings.Trim(path, "/"), "/")
    if len(parts) >= 2 {
        return parts[1]
    }
    return ""
}

func respondJSON(w http.ResponseWriter, status int, payload any) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    _ = json.NewEncoder(w).Encode(payload)
}

6) Application Entry Point

cmd/api/main.go

package main

import (
    "log"
    "net/http"

    httpadapter "example.com/hexagonal-go/internal/adapters/http"
    "example.com/hexagonal-go/internal/adapters/persistence/memory"
    "example.com/hexagonal-go/internal/application"
)

func main() {
    repo := memory.NewOrderRepository()
    service := application.NewOrderService(repo)
    handler := httpadapter.NewOrderHandler(service)

    mux := http.NewServeMux()
    handler.RegisterRoutes(mux)

    log.Println("server started on :8080")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatal(err)
    }
}

7) How It Works

• HTTP adapter receives the request
• Application service executes the use case
• Domain applies business rules
• Repository (port) is defined in the domain
• Adapter (memory) implements it

👉 The domain layer:

• does NOT know net/http
• does NOT know databases
• does NOT know frameworks

8) Simple Test Example

internal/domain/order/order_test.go

package order

import "testing"

func TestOrderCompleteWithoutItems(t *testing.T) {
    o := NewOrder("1")

    if err := o.Complete(); err == nil {
        t.Fatal("expected error when completing empty order")
    }
}

func TestOrderTotal(t *testing.T) {
    o := NewOrder("1")
    price, _ := NewMoney(500)

    if err := o.AddItem("p1", 2, price); err != nil {
        t.Fatal(err)
    }

    if o.Total().Cents != 1000 {
        t.Fatalf("expected 1000, got %d", o.Total().Cents)
    }
}

9) Run the Project

go run ./cmd/api

Example requests:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

curl -X POST localhost:8080/orders/ord_xxx/complete

hexagonal-go/
├── go.mod
├── cmd/
│   └── api/
│       └── main.go
└── internal/
    ├── domain/
    │   └── order/
    │       ├── money.go
    │       ├── order.go
    │       ├── order_id.go
    │       ├── order_status.go
    │       └── repository.go
    ├── application/
    │   └── order_service.go
    └── adapters/
        ├── http/
        │   └── order_handler.go
        └── persistence/
            └── memory/
                └── order_repository.go

1) go.mod

module example.com/hexagonal-go

go 1.22

2) Domain katmanı

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.go

package order

import "fmt"

type Money struct {
    Cents int64
}

func NewMoney(cents int64) (Money, error) {
    if cents < 0 {
        return Money{}, fmt.Errorf("money cannot be negative")
    }
    return Money{Cents: cents}, nil
}

func (m Money) Add(other Money) Money {
    return Money{Cents: m.Cents + other.Cents}
}

internal/domain/order/order.go

package order

import "fmt"

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice Money
}

type Order struct {
    id     OrderID
    items  []OrderItem
    status OrderStatus
}

func NewOrder(id OrderID) *Order {
    return &Order{
        id:     id,
        items:  make([]OrderItem, 0),
        status: OrderStatusCreated,
    }
}

func (o *Order) ID() OrderID {
    return o.id
}

func (o *Order) Status() OrderStatus {
    return o.status
}

func (o *Order) Items() []OrderItem {
    copied := make([]OrderItem, len(o.items))
    copy(copied, o.items)
    return copied
}

func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error {
    if o.status != OrderStatusCreated {
        return fmt.Errorf("order cannot be modified after completion")
    }
    if productID == "" {
        return fmt.Errorf("product id cannot be empty")
    }
    if quantity <= 0 {
        return fmt.Errorf("quantity must be greater than zero")
    }

    o.items = append(o.items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    })

    return nil
}

func (o *Order) Complete() error {
    if len(o.items) == 0 {
        return fmt.Errorf("order must have at least one item")
    }
    o.status = OrderStatusCompleted
    return nil
}

func (o *Order) Total() Money {
    total := Money{Cents: 0}
    for _, item := range o.items {
        total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)})
    }
    return total
}

internal/domain/order/repository.go

package order

import "context"

type Repository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id OrderID) (*Order, error)
}

3) Application katmanı

internal/application/order_service.go

package application

import (
    "context"
    "fmt"
    "time"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderService struct {
    repo order.Repository
}

func NewOrderService(repo order.Repository) *OrderService {
    return &OrderService{repo: repo}
}

func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) {
    id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano()))
    newOrder := order.NewOrder(id)

    if err := s.repo.Save(ctx, newOrder); err != nil {
        return nil, err
    }

    return newOrder, nil
}

func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    price, err := order.NewMoney(priceCents)
    if err != nil {
        return nil, err
    }

    if err := o.AddItem(productID, quantity, price); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    if err := o.Complete(); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    return s.repo.FindByID(ctx, orderID)
}

4) Persistence adapter (in-memory)

internal/adapters/persistence/memory/order_repository.go

package memory

import (
    "context"
    "fmt"
    "sync"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderRepository struct {
    mu     sync.RWMutex
    orders map[order.OrderID]*order.Order
}

func NewOrderRepository() *OrderRepository {
    return &OrderRepository{
        orders: make(map[order.OrderID]*order.Order),
    }
}

func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error {
    r.mu.Lock()
    defer r.mu.Unlock()

    r.orders[o.ID()] = o
    return nil
}

func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    o, ok := r.orders[id]
    if !ok {
        return nil, fmt.Errorf("order not found: %s", id)
    }

    return o, nil
}

5) HTTP adapter

internal/adapters/http/order_handler.go

package httpadapter

import (
    "encoding/json"
    "net/http"
    "strings"

    "example.com/hexagonal-go/internal/application"
    "example.com/hexagonal-go/internal/domain/order"
)

type OrderHandler struct {
    service *application.OrderService
}

func NewOrderHandler(service *application.OrderService) *OrderHandler {
    return &OrderHandler{service: service}
}

func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) {
    mux.HandleFunc("POST /orders", h.createOrder)
    mux.HandleFunc("GET /orders/", h.getOrder)
    mux.HandleFunc("POST /orders/{id}/items", h.addItem)
    mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder)
}

func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) {
    o, err := h.service.CreateOrder(r.Context())
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    respondJSON(w, http.StatusCreated, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.GetOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "items":  o.Items(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)

    var req struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
        PriceCents int64  `json:"price_cents"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid json", http.StatusBadRequest)
        return
    }

    o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func extractID(path string) string {
    parts := strings.Split(strings.Trim(path, "/"), "/")
    if len(parts) >= 2 {
        return parts[1]
    }
    return ""
}

func respondJSON(w http.ResponseWriter, status int, payload any) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    _ = json.NewEncoder(w).Encode(payload)
}

6) Uygulama başlangıcı

cmd/api/main.go

package main

import (
    "log"
    "net/http"

    httpadapter "example.com/hexagonal-go/internal/adapters/http"
    "example.com/hexagonal-go/internal/adapters/persistence/memory"
    "example.com/hexagonal-go/internal/application"
)

func main() {
    repo := memory.NewOrderRepository()
    service := application.NewOrderService(repo)
    handler := httpadapter.NewOrderHandler(service)

    mux := http.NewServeMux()
    handler.RegisterRoutes(mux)

    log.Println("server started on :8080")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatal(err)
    }
}

7) Akış nasıl çalışıyor?

• HTTP adapter isteği alır.
• Application service use-case’i yürütür.
• Domain iş kurallarını uygular.
• Repository port domain tarafından tanımlanır.
• Memory adapter bu portu implement eder.

Bu yapı sayesinde domain katmanı:

• net/http bilmez,
• database bilmez,
• framework bilmez.

8) Kısa test örneği

internal/domain/order/order_test.go

package order

import "testing"

func TestOrderCompleteWithoutItems(t *testing.T) {
    o := NewOrder("1")

    if err := o.Complete(); err == nil {
        t.Fatal("expected error when completing empty order")
    }
}

func TestOrderTotal(t *testing.T) {
    o := NewOrder("1")
    price, _ := NewMoney(500)

    if err := o.AddItem("p1", 2, price); err != nil {
        t.Fatal(err)
    }

    if o.Total().Cents != 1000 {
        t.Fatalf("expected 1000, got %d", o.Total().Cents)
    }
}

9) Çalıştırma

go run ./cmd/api

Örnek istek:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

curl -X POST localhost:8080/orders/ord_xxx/complete

However, there are two critical security nuances to consider:

Residual Risks in Open Tabs

If a malicious extension was active and you disabled it while having several tabs open, its “content scripts” might still be running in those specific pages until they are refreshed. stackoverflow

• These scripts could potentially leak data through indirect methods like hidden images or CSS if the site’s Content Security Policy (CSP) is weak. stackoverflow
• Solution: You must refresh all open tabs or restart your browser after disabling an extension to ensure all its scripts are fully cleared. stackoverflow

Previously Stolen Data

Disabling an extension only stops future data collection; it does not “undo” what was already stolen while the extension was active. youtube

• If a malicious extension captured your passwords, session cookies, or personal data while it was enabled, that information is likely already stored on the attacker’s server (C2 server). linkedin
• Attackers often use stolen session tokens to maintain access to your accounts even after the extension is deleted. thehackernews

Extension Status Comparison

The following table illustrates the capabilities of an extension based on its state:

If you suspect an extension is malicious, simply disabling it is not enough. You should remove it entirely, clear your browser cookies, and change your passwords for sensitive accounts. support.google

Which specific extension are you concerned about?

Ancak güvenlik açısından dikkat edilmesi gereken iki önemli istisna bulunmaktadır:

Aktif Sekmelerdeki Kalıntı Riskler

Bir eklentiyi devre dışı bıraktığınız an, o sırada açık olan sekmelerde halihazırda enjekte edilmiş olan “içerik betikleri” (content scripts) çalışmaya devam edebilir. stackoverflow

• Bu betikler eklenti merkezine veri gönderemez ancak sitenin kendi güvenlik politikası (CSP) zayıfsa, verileri gizli görseller veya CSS üzerinden dışarı sızdırmaya çalışabilir. stackoverflow
• Çözüm: Eklentiyi kapattıktan sonra açık olan tüm sekmeleri yenilemek (Refresh) bu riski tamamen ortadan kaldırır. stackoverflow

Geçmişte Toplanan Veriler

Eklentinin devre dışı bırakılması sadece gelecekteki veri akışını keser.

• Eğer eklenti aktif olduğu süre boyunca şifrelerinizi, çerezlerinizi (cookies) veya kişisel verilerinizi uzak bir sunucuya (C2 server) gönderdiyse, bu veriler saldırganın elinde kalmaya devam eder. youtube
• Kötü niyetli eklentiler genellikle oturum jetonlarını (session tokens) çalarak, siz eklentiyi silseniz bile hesaplarınıza erişim sağlamaya devam edebilir. linkedin

Güvenli Kullanım Tablosu

Eklenti durumuna göre yetki ve risk dağılımı şu şekildedir:

Şüphelendiğiniz bir eklenti varsa sadece devre dışı bırakmak yerine doğrudan kaldırmanız ve ardından tarayıcı çerezlerini temizleyerek şifrelerinizi değiştirmeniz en güvenli yoldur. thehackernews

Hangi eklenti hakkında bu endişeyi taşıyorsunuz?

Eğitim Sistemi Sorunları

Yıllarca İngilizce dersi alınmasına rağmen konuşma becerisi düşük çünkü sistem ezber ve gramer odaklı; sınav baskısı (test-tost arasında sıkışma) üretken becerileri (konuşma-yazma) engelliyor. youtube Hazırlık sınıflarının kaldırılması ve kalitesiz materyaller/hocalar yeterliliği düşürüyor; 1000 saat ders sonrası %90 konuşamama oranı görülüyor. tepav.org

Diğer Etkenler

Sınıf ortamında yeterli maruziyet ve pratik eksikliği var; gençlerde pandemi sonrası toparlanma yok, 40+ yaşta ise gerileme belirgin. tr.investing Psikolojik nedenler (motivasyon kaybı) ve ana dilde eğitim tartışmaları İngilizceyi gölgeliyor; TOEFL skorları Sudan’la aynı seviyede. tepav.org

High‑level summary

For a growing, medium‑sized business that expects to automate more and more over time:

• Choose n8n if you have developers/DevOps, care about data control, and want the lowest long‑term total cost of ownership.
• Choose Make if you want powerful visual workflows and good pricing but prefer not to run your own infrastructure.
• Use Zapier sparingly for very simple, low‑volume automations or where its huge app catalog is a hard requirement.

parseur

Quick comparison table

Cost and scalability over the long term

Zapier counts every step as a task, including filters, formatters, and branches, so any non‑trivial workflow multiplies your task usage. That makes it very predictable but also very expensive once you hit thousands or tens of thousands of records per month; many reviews show Zapier becoming the costliest of the three at medium–high scale. lumberjack

Make’s operation‑based billing is significantly more forgiving. The free tier gives 1,000 operations, and around 9–10 USD/month buys you 10,000 operations, often 40–60% cheaper than a comparable Zapier workload. However, it is still consumption‑based: badly designed or very chatty workflows (especially with AI modules) can burn through credits faster than expected. neondigitalmedia

With n8n, self‑hosting removes per‑task licensing altogether: you pay for infrastructure only, and execution‑based counting (in cloud plans) means a 5‑step flow and a 200‑step AI agent can both cost “1 execution” if they run once. At medium and high complexity, this often translates into order‑of‑magnitude savings versus Zapier and clear savings versus Make, especially if you’re comfortable tuning your own server. xcloud

Technical flexibility, self‑hosting, and data control

Zapier and Make are pure SaaS: you get vendor‑managed security, uptime, and scaling, but your data must flow through their cloud and remain within their compliance boundaries. For many SMBs this is fine; for regulated industries, strict data‑residency requirements, or customers who require on‑prem options, this can be a blocker. summarizemeeting

n8n’s biggest differentiator is self‑hosting: you can run it on your own infrastructure (or a dedicated VPS), keep data within your own network/VPC, and control latency, retention, and throughput limits yourself. That makes it very attractive for medium‑sized companies that either already run containers/servers or are willing to invest in that capability, because you are no longer locked into a vendor’s rate limits and roadmaps. contabo

Integrations and UX

Zapier has the widest app catalog, so for very niche SaaS tools it often “just works” without custom HTTP work. Its linear trigger‑→‑action model and library of templates let marketing, sales, and ops teams build simple flows (like “when a new lead is created, send a Slack message and add to a sheet”) with almost no guidance. digidop

Make’s canvas‑style editor is much better for visually complex flows: you can see branches, error paths, and parallel routes on a single diagram, which is extremely useful for medium‑sized businesses with tangled processes. Connectors often expose deeper object fields than the Zapier equivalents, and built‑in transformers make it easy to massage data without code. lumberjack

n8n’s editor also uses a node‑based graph, but leans more toward a developer‑friendly tool: custom JavaScript, HTTP nodes, and advanced logic are standard, and you can extend it with your own nodes or packages. The trade‑off is that non‑technical users generally need some enablement; n8n is superb as a central automation “platform” owned by engineering, less so as a self‑service toy for every department. reddit

AI and advanced automation

Zapier focuses on making AI easy, not deep: natural‑language automation builders and simple ChatGPT/OpenAI steps that any user can drop into flows. This works well for simple classification or content‑generation tasks but offers limited control over advanced agent‑style patterns. parseur

Make gives you strong AI connectors (OpenAI and others) and lets you wire them into complex routes and transformations; however, AI modules consume operations, which can push bills up for heavy usage. thinkpeak

n8n currently leads on technical AI depth: LangChain nodes, support for multiple LLM providers, and the ability to compose RAG pipelines and agents directly in workflows. Combined with execution‑based pricing and self‑hosting, this makes n8n particularly attractive for medium‑sized companies planning to run serious AI workloads (document QA, routing, enrichment, ticket triage, etc.) through automation. blog.n8n

Practical guidance for medium‑sized businesses

• If you have real dev/DevOps capacity and automation is strategic
  Use n8n as your core automation layer, preferably self‑hosted. You get long‑term cost control, strong AI capabilities, and full data sovereignty, at the price of some infra and governance work. xcloud

• If your technical capacity is limited but business teams want complex workflows
  Make is usually the sweet spot: far cheaper and more powerful than Zapier for medium‑complexity flows, but still SaaS and relatively easy to onboard power users onto. neondigitalmedia

• If you mainly need a few simple automations and ultra‑fast non‑technical adoption
  Zapier can still be the right choice, especially in the early stage or for isolated use cases—just be aware that if volume and complexity grow, migration to Make or n8n is a likely future step. digidop

Given your background (strong engineering, comfortable with Docker and backends), for any company you build or advise, a hybrid of “n8n as the backbone + Make for certain visual/no‑code friendly flows” will almost always give the best long‑term mix of cost, control, and usability. summarizemeeting

Temel tablo özeti

Maliyet ve ölçeklenebilirlik

Zapier, her adımı ayrı “task” olarak fiyatladığı için (filtreler, formatter’lar, dallanmalar dahil) karmaşık iş akışlarında ve binlerce işlem/ay seviyesinde maliyet çok hızlı yukarı tırmanıyor. 10.000 task/ay civarında dahi, Zapier’in toplam maliyeti 200 $/ay ve üzeri seviyelere çıkabildiği belirtiliyor. stackby

Make, operasyon/credit bazlı modeliyle başlangıçta oldukça ucuz: 10.000 operasyon için Core plan ~10–11 $/ay bandında, bu da Zapier’e göre büyük avantaj. Ancak 2026 itibarıyla kredi modeline geçiş, AI modülleri için ek kredi tüketimi ve “complexity billing” yüzünden kötü tasarlanmış senaryolar ölçek büyüdükçe beklenenden pahalı hâle gelebiliyor. thinkpeak

n8n tarafında, self‑host kurulumda yazılım lisans bedeli yok; sadece sunucu masrafı (çoğu orta ölçekli senaryo için ~20 $/ay seviyesinde bir VPS yeterli) söz konusu ve execution bazlı model, 2 adımlık bir akışla 200 adımlık bir AI ajanını aynı “1 execution” olarak saydığı için yüksek karmaşıklıkta %90+ maliyet avantajı sağlayabildiği örneklerle anlatılıyor. Cloud sürümünde 10.000 execution için ~60 $/ay civarı, hâlâ Zapier’den ucuz ama Make’in bazı planlarına göre daha pahalı; buna karşılık self‑host seçeneği sayesinde toplam sahip olma maliyeti, teknik ekibi olan işletmelerde uzun vadede en düşük olma eğiliminde. summarizemeeting

Teknik esneklik, self‑hosting ve veri kontrolü

Zapier ve Make tamamen SaaS olduğundan, verileriniz onların altyapısından geçmek zorunda; buna karşılık SOC2/ISO gibi sertifikalarla güvenlik sunuyorlar ama veri egemenliği konusundaki son söz sizde değil. n8n ise açık kaynak/fair‑code yapısı ve self‑hosting seçeneği ile, özellikle GDPR/HIPAA benzeri regülasyon hassasiyeti olan veya müşteri datasını ülkede tutmak isteyen işletmelere tam veri kontrolü veriyor. parseur

Self‑host n8n senaryosunda; ölçeklendirme stratejilerini (kuyruk, worker sayısı, trigger sıklığı vs.) tamamen kendi SRE/DevOps yaklaşımınıza göre ayarlayabiliyor, gerektiğinde sadece altyapı büyüterek sınırsız workflow çalıştırabiliyorsunuz. Buna karşılık, bu özgürlük operasyonel yük getiriyor: sunucu yönetimi, yedekleme, güncelleme ve izleme için ya içerde bir ekip ya da dışarıdan managed hizmet almak gerekiyor; bu da teknik kapasitesi zayıf işletmeler için dezavantaj. contabo

Entegrasyon kapsaması ve kullanım deneyimi

Zapier, ~8.700+ uygulamayla en geniş entegrasyon kütüphanesine sahip ve özellikle niş SaaS ürünlerine bağlanmak gerektiğinde “en güvenli seçim” olabiliyor. Arayüz, lineer “trigger–action” mantığında olduğu için pazarlama/operasyon gibi teknik olmayan ekiplerin bile birkaç saat içinde kendi otomasyonlarını kurabilmesini sağlıyor. neondigitalmedia

Make, canvas tabanlı görsel builder’ı ve router, error route, paralel path gibi gelişmiş özellikleriyle daha karmaşık iş süreçlerini kullanıcıya çok net görselleştiriyor; bu da orta ölçekli işletmelerde “iş analisti + power user” profili için oldukça ideal. n8n’in node tabanlı mimarisi de benzer şekilde gelişmiş dallanma, hata yönetimi ve custom code node’ları sunuyor; ancak kurulum ve temel JavaScript bilgisi gerektirdiğinden teknik olmayan son kullanıcılar için learning curve belirgin şekilde daha yüksek. summarizemeeting

AI ve ileri seviye otomasyon

Zapier, AI tarafında daha çok “herkes için kolaylaştırma”yı hedefliyor; doğal dil ile otomasyon yaratma, ChatGPT entegrasyonu vb. var ama derin özelleştirme ve ajan mimarileri sınırlı. Make, OpenAI/Anthropic modülleri ve AI destekli veri dönüşümleriyle orta seviye esneklik sunuyor; fakat AI modüllerinin kredi tüketimi toplam maliyeti yukarı çekebiliyor. thinkpeak

n8n ise LangChain entegrasyonu, onlarca AI node’u ve farklı model sağlayıcılarıyla daha çok “teknik ekiplerin AI ajanları ve RAG tabanlı sistemler kurduğu” bir platform hâline gelmiş durumda. Orta ölçekte ciddi AI iş yükü olan, örneğin ticket sınıflandırma, doküman bazlı soru‑cevap, müşteri etkileşim otomasyonu gibi senaryolarda, execution bazlı model ve self‑host imkânı maliyet/performans dengesini n8n lehine çeviriyor. nicksaraev

Orta ölçekli işletmeler için pratik öneri

• Teknik ekibiniz (dev/DevOps) VAR ve otomasyon sizin için stratejik bir katman olacaksa:
  Çekirdek otomasyon altyapısını n8n (özellikle self‑host) üzerine kurmak uzun vadede genellikle en avantajlı seçenek; hem maliyet hem de esneklik/veri egemenliği açısından. latenode

• Teknik ekibiniz sınırlı ama iş birimleri karmaşık akışlar istiyor, Zapier maliyeti gözünüze batmaya başladıysa:
  Çoğu orta ölçekli işletme için Make, Zapier’e göre çok daha sürdürülebilir maliyet ve daha zengin workflow tasarım imkânı sunuyor; bakım yükü de n8n self‑host kadar ağır değil. parseur

• Tamamen non‑technical, az sayıda basit otomasyon ve düşük hacim planlıyorsanız:
  Küçük/başlangıç senaryosunda Zapier hâlâ “en hızlı sonuç veren”, iş birimlerinin en rahat adapte olduğu çözüm; ama orta vadede hacmin artacağı öngörülüyorsa, ilk günden Zapier’e kilitlenmek yerine Make veya n8n tarafını stratejik platform olarak düşünmek genelde daha sağlıklı. thatapicompany

Senin profilini (geliştirici geçmişin, Docker/sunucu yönetimine alışık olman vb.) düşününce, kendi şirketinde ya da danışmanlık vereceğin orta ölçekli firmalarda n8n + gerektiğinde Make kombinasyonu uzun vadede hem maliyet hem kontrol açısından büyük olasılıkla en mantıklı mimari olacaktır. nicksaraev

Nasıl Kullanılır

n8n’i kullanmak için öncelikle Docker ile yerel kurulum yapın veya resmi siteden (n8n.io) bulut hesabı oluşturun. Görsel arayüzde “node”ları sürükle-bırak ile ekleyin: tetikleyici (örneğin webhook veya zamanlama), işlem (HTTP istek, OpenAI entegrasyonu) ve çıktı node’larını bağlayın. JavaScript/Python kodu ekleyerek özelleştirin, workflow’u test edin ve aktif hale getirin; hata yönetimi için Error Trigger node’u kullanın. eksisozluk

Faydaları

n8n, tekrar eden görevleri otomatikleştirerek zaman tasarrufu sağlar ve manuel hataları azaltır. Geniş entegrasyon kataloğu (Google Sheets, Slack, CRM’ler) ile veri senkronizasyonu ve AI ajanları oluşturmayı kolaylaştırır, self-hosted seçenekle veri güvenliği sunar. No-code/low-code yaklaşımıyla geliştiriciler ve citizen developer’lar için idealdir, kurumsal ölçekte RBAC ve audit log gibi özelliklerle verimliliği artırır. uretkenzeka