AI ile Sözleşme Yenileme Bildirimlerini Otomatikleştirerek Sorunsuz Yönetim

SaaS, startup ve uzaktan ekiplerin hızlı dünyasında sözleşme süresi dolması sessiz bir tehdit oluşturur. Yenileme tarihlerini kaçırmak hizmet kesintilerine, hukuki risklere ya da gelir kaybına yol açabilir. Contractize.app, NDA’lardan Yazılım Lisans Sözleşmelerine kadar zengin bir şablon kütüphanesi sunsa da, çoğu kullanıcı yenilemeleri hâlâ manuel olarak, genellikle elektronik tablo ya da takvim hatırlatmalarına dayanarak gerçekleştirmektedir.

Ya yenileme yaşam döngüsünün tamamını, her sözleşmeyi izleyen, ne zaman bir yeniden görüşme gerektiğini tahmin eden ve doğru paydaşa doğru mesajı doğru zamanda gönderen akıllı bir asistanla devretseydiniz? Bu makale, modern AI hizmetleri, düşük‑kod iş akışı platformları ve Contractize.app API’si kullanarak böyle bir sistemi nasıl inşa edeceğinizi gösterir.

Ana fikir: İyi tasarlanmış bir yenileme bildirim motoru, kaçırılan yenileme oranını > %80 azaltırken hukuk ekiplerinin daha yüksek katma değerli işlere odaklanmasını sağlar.

1. Neden Ayrı Bir Yenileme Motoru Önemlidir

Bir Veri İşleme Sözleşmesi (DPA)’yı GDPR denetimi öncesinde bulmak için koşuşturmalarınız olduysa, kötü yenileme yönetiminin maliyetini zaten biliyorsunuzdur. AI‑destekli bir motor bu koşuşturmayı ortadan kaldırır.

2. Temel Mimari Genel Bakış

Aşağıda yenileme otomasyonu yığınına ait yüksek‑seviyeli bir diyagram yer almaktadır:

+-------------------+        +----------------------+        +-------------------+
| Contractize.app  | <----> |  Sözleşme Metaverisi | <----> |  AI Yenileme Motoru|
|  (Şablon API)    |        |   (PostgreSQL)       |        +-------------------+
+-------------------+        +----------------------+                 |
        ^                                 ^                         |
        |                                 |                         |
        |   Sözleşme Oluştur / Güncelle   |   Son Kullanım Tarihlerini Çek |
        |                                 |                         |
        v                                 v                         v
+-------------------+        +----------------------+        +-------------------+
|  Ön‑yüz UI        | -----> |  Zamanlayıcı / Cron  | -----> | Bildirim Merkezi |
|  (React/Vue)      |        |  (Temporal.io)       |        | (Twilio, SendGrid)|
+-------------------+        +----------------------+        +-------------------+

• Contractize.app API – Sözleşmeyi oluşturur, benzersiz bir contract_id döndürür ve son PDF’i güvenli bir bucket’a kaydeder.
• Metaveri Deposu – Taraflar, yürürlük tarihi, sona erme tarihi, yenileme maddesi ve renewal_status bayrağı gibi sözleşme ayrıntılarını tutar.
• AI Yenileme Motoru – Metaveriyi okuyan, bir risk‑puanlama modeli çalıştıran ve ne zaman ve nasıl bildirim gönderileceğine karar veren mikroservistir (Python/Node).
• Zamanlayıcı – Temporal.io iş akışı, sona ermeden 30 gün, 14 gün ve 3 gün önce (sözleşme türüne göre ayarlanabilir) motoru tetikler.
• Bildirim Merkezi – Çok kanallı uyarılar (e‑posta, Slack, SMS) gönderen hizmet (Twilio, SendGrid vb.) ve şablonlu mesajlar.

Bu bütünleme AWS (Lambda, RDS, SNS) üzerinde gösterilmiştir; ancak kavramlar GCP veya Azure’da da aynı şekilde uygulanabilir.

3. Sözleşme Metaveri Deposu Kurulumu

3.1 Şema Tasarımı

CREATE TABLE contracts (
    contract_id          UUID PRIMARY KEY,
    template_type        VARCHAR(64) NOT NULL,
    party_a_name         VARCHAR(255) NOT NULL,
    party_b_name         VARCHAR(255) NOT NULL,
    effective_date       DATE NOT NULL,
    expiration_date      DATE NOT NULL,
    renewal_notice_days  INT DEFAULT 30,
    renewal_status       VARCHAR(20) DEFAULT 'pending',
    last_notified_at     TIMESTAMP,
    created_at           TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at           TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

renewal_notice_days alanı, farklı sözleşme türleri için özelleştirilebilir bir uyarı süresi (ör. Yazılım Lisans Sözleşmesi için 90 gün) tanımlamayı sağlar.

3.2 Tabloyu Doldurma

Kullanıcı Contractize.app üzerinden bir sözleşmeyi tamamlarken ön uç şu isteği gönderir:

POST https://api.contractize.app/v1/contracts
{
  "template_id": "software_license",
  "party_a": "Acme Corp",
  "party_b": "Beta Solutions",
  "effective_date": "2025-10-01",
  "expiration_date": "2026-09-30",
  "renewal_notice_days": 45
}

API bir contract_id döndürür. UI, bu contract_id ile webhook tetikleyerek contracts tablosuna bir satır yazar. Bu webhook, örneğin bir AWS Lambda fonksiyonu olabilir.

4. AI Yenileme Motorunu Oluşturma

4.1 Hangi Tür AI?

Bu motor tam ölçekli Büyük Dil Modeli (LLM) gerektirmez. Gradient‑boosted tree (ör. XGBoost) modeli, geçmiş yenileme sonuçlarına dayanarak en uygun bildirim zamanı ve yenileme olasılığını tahmin edebilir. Girdi özellikleri şunlardır:

Model, risk puanı (0‑100) üretir. 70’in üzerindeki puanlar, erken “pre‑renewal” uyarısı tetikleyerek hukuk ekibinin müzakereye daha erken başlamasını sağlar.

4.2 Model Eğitim Boru Hattı

1. Veri Çekimi – Metaveri deposundan tarihsel sözleşme verileri alın.
2. Etiketleme – Sözleşmelerin yenilenip yenilenmediğine göre 1 (yenilendi) / 0 (yenilenmedi) etiketi verin.
3. Eğitim – sklearn veya xgboost ile modeli eğitin.
4. Dağıtım – REST uç noktası olarak (ör. AWS SageMaker veya basit FastAPI) yayınlayın.

from fastapi import FastAPI
import joblib, pandas as pd

app = FastAPI()
model = joblib.load('renewal_model.pkl')

@app.post("/predict")
def predict(data: dict):
    df = pd.DataFrame([data])
    prob = model.predict_proba(df)[:,1][0]
    return {"renewal_probability": prob}

4.3 Zamanlayıcı ile Entegrasyon

Temporal.io iş akışı, her çalıştırmada AI uç noktasını çağırır:

async def renewal_workflow(contract_id: str):
    contract = await fetch_contract(contract_id)
    days_left = (contract.expiration_date - datetime.utcnow().date()).days
    payload = {
        "days_to_expiry": days_left,
        "contract_value": contract.value,
        "renewal_clause": contract.renewal_clause,
        "engagement_score": contract.engagement_score,
        "risk_flag": contract.risk_flag
    }
    result = await http.post("https://ai.renewal.service/predict", json=payload)
    prob = result.json()["renewal_probability"]
    if prob > 0.7:
        await send_notification(contract_id, "early")
    else:
        await send_notification(contract_id, "standard")

İş akışı, sözleşmenin renewal_notice_days değerine göre kendini otomatik yeniden zamanlar.

5. Akıllı Bildirim Şablonları Oluşturma

İyi bir bildirim üç şeyi yapar:

1. Aciliyeti belirtir (“30 gün içinde sona eriyor”).
2. Eylem bağlantıları sunar (yeni sözleşmeyi oluşturmak için Contractize.app linki).
3. Uyumluluk notları ekler (ör. “GDPR’ye uygun kalmak için yenileme gerekli”).

E-posta şablonu (Handlebars):

Subject: {{days_left}}‑Gün Bildirimi – {{template_type}} Yenilemesi Gerekiyor

Merhaba {{owner_name}},

{{counterparty}} ile yaptığınız {{template_type}} (ID: {{contract_id}}) {{expiration_date}} tarihine kadar geçerlidir.

**Önerilen Eylem:**  
[Şimdi Yenile]({{renewal_url}}) – En son şablonları kullanarak güncellenmiş bir sözleşme oluşturur.

**Uyumluluk Hatırlatması:**  
Kişisel veri işleyen sözleşmeler (ör. DPAlar) için zamanında yenileme, **GDPR** ve **CCPA** uyumluluğunuzun devamını sağlar.

Yardım gerekirse bu e-postayı yanıtlayın ya da Slack’te hukuk operasyonları kanalına mesaj gönderin.

Teşekkürler,  
Contractize.app Otomatik Yenileme Botu

Bildirim Merkezi (SendGrid, Twilio, Slack Webhook) yukarıdaki yer tutucuları metaveri tablosundan gelen gerçek değerlerle doldurur.

6. Baştan Sona İş Akışı

1. Kullanıcı sözleşme oluşturur → Contractize.app contract_id döndürür.
2. Webhook metaveri yazar → contracts tablosuna bir satır eklenir.
3. Temporal iş akışı zamanlar → Sona ermeden 30 gün önce ilk tetikleme.
4. AI motoru puanlamasını yapar → Yüksek risk ise erken uyarı gönderilir.
5. Sahip uyarıyı alır → “Yenile” butonuna tıklar, Contractize.app aynı şablonu ön‑doldurmuş yeni bir sözleşme üretir.
6. Yenileme tamamlanır → Metaveri satırı renewal_status = 'completed' ve last_notified_at güncellenir.

Tüm adımlar CloudWatch (veya GCP Stackdriver) üzerinden loglanır, denetim izlenebilirliği sağlar.

7. Güvenlik ve Uyumluluk Kontrol Listesi

Bu listeye uyum, yenileme motorunun kendisinin yeni bir uyumluluk riski oluşturmasını engeller.

8. Çözümün Ölçeklendirilmesi

• Çok‑müşterili SaaS – tenant_id ile sözleşmeleri bölümlendir ve PostgreSQL’de satır‑seviye güvenlik kullan.
• Yoğun uyarı trafiği – Çoklu kanallara yönlendirmek için AWS SNS fan‑out kullan, throttling sorunu yaşamazsınız.
• Sunucusuz hesaplama – Temporal işçisini AWS Step Functions + Lambda ile tamamen yönetilen bir iş akışına dönüştür.
• Gözlemlenebilirlik – OpenTelemetry ile bir istek UI‑AI‑bildirim zincirini izleyerek latency ve hataları görselleştirin.

Bu tasarımla ayda yüz binlerce sözleşmeyi sorunsuzca işleyebilirsiniz.

9. Hızlı Başlangıç Betiği (Terraform + Python)

Aşağıda AWS üzerindeki temel kaynakları kurmak için minimal bir Terraform örneği yer alıyor:

provider "aws" {
  region = "us-east-1"
}

resource "aws_rds_cluster" "contracts_db" {
  engine          = "aurora-postgresql"
  engine_version  = "15.4"
  master_username = "admin"
  master_password = random_password.db_pass.result
  storage_encrypted = true
}

resource "aws_lambda_function" "webhook" {
  filename         = "webhook.zip"
  function_name    = "contractize_webhook"
  handler          = "webhook.handler"
  runtime          = "python3.11"
  role             = aws_iam_role.lambda_exec.arn
  environment {
    variables = {
      DB_ENDPOINT = aws_rds_cluster.contracts_db.endpoint
    }
  }
}

Python webhook (Lambda) kodu – gelen payload’u contracts tablosuna kaydeder:

import json, os, psycopg2

def handler(event, context):
    payload = json.loads(event['body'])
    conn = psycopg2.connect(
        host=os.getenv('DB_ENDPOINT'),
        dbname='contracts',
        user='admin',
        password=os.getenv('DB_PASSWORD')
    )
    cur = conn.cursor()
    cur.execute("""
        INSERT INTO contracts (contract_id, template_type, party_a_name, party_b_name,
                               effective_date, expiration_date, renewal_notice_days)
        VALUES (%s, %s, %s, %s, %s, %s, %s)
    """, (
        payload['contract_id'],
        payload['template_type'],
        payload['party_a'],
        payload['party_b'],
        payload['effective_date'],
        payload['expiration_date'],
        payload.get('renewal_notice_days', 30)
    ))
    conn.commit()
    cur.close()
    conn.close()
    return {
        'statusCode': 200,
        'body': json.dumps({'message': 'contract recorded'})
    }

Terraform’u çalıştırın, zip dosyasını Lambda’ya yükleyin ve webhook’u Contractize.app entegrasyon sayfasından etkinleştirin; böylece üretime hazır bir veri akışı elde edersiniz.

10. Başarı Ölçümü

Grafana panosu oluşturun; CloudWatch’tan (gönderilen bildirim sayısı, AI güven puanı, tamamlanan yenilemeler) metrikleri çekerek yöneticilere gerçek zamanlı rapor sunun.

11. Yaygın Tuzaklar ve Kaçınma Yolları

Erken aşamada bu sorunları ele almak zaman ve güven kaybını önler.

12. Ekibiniz İçin Sonraki Adımlar

1. Mevcut sözleşme envanterinizi denetleyin ve her birine renewal_notice_days değeri atayın.
2. Contractize.app webhook’unu “Entegrasyonlar” menüsünden aktif edin.
3. Terraform betiğini bir test AWS hesabına dağıtın.
4. AI modelinizi en az 6 aylık tarihsel veriyle eğitin.
5. Pilot uygulama olarak tek bir sözleşme türünde (ör. NDA) çalıştırın, bildirim içeriğini iyileştirin.
6. Aşamalı genişleme – yeni sözleşme tiplerini ekleyin, çok‑kanallı uyarıları (SMS, Slack) devreye alın.

Bu yol haritasını izleyerek, manuel ve hatalı yenileme süreçlerini akıllı, otomatik ve uyumlu bir yenileme motoruna dönüştürmüş olacaksınız.

İlgili İçerikler

• Sözleşme Yaşam Döngüsü Yönetimi (CLM) En İyi Uygulamalar – IACCM
• Temporal.io İş Akışı Orkestrasyon Kılavuzu
• OpenTelemetry ile Gözlemlenebilirlik – CNCF
• GDPR Veri İşleme Sözleşmeleri – Avrupa Komisyonu