GovStack: Dijital Devlet için Modüler Çerçeve

GovStack tarafından 2020 yılında başlatılan uluslararası bir girişimdir. Estonya, Almanya, ITU (Uluslararası Telekomünikasyon Birliği) e DIAL (Dijital Etki Birliği) ile hizmet oluşturmak için gereken araçları, bilgileri ve en iyi uygulamaları paylaşma hedefi Her seferinde sıfırdan başlamanıza gerek kalmadan geniş ölçekte dijital kitlelere ulaşın.

Temel fikir basit ama güçlü: Ülke başına monolitik sistemler geliştirmek yerine, her biri Devletin dijital hizmeti şu şekilde ayrıştırılmıştır: Yapı Bloğu (fonksiyonel modüller) hangi belirli bir yetenek sunarlar (kimlik, ödemeler, mesajlaşma, kayıtlar vb.) ve bu herhangi bir hizmeti oluşturmak için serbestçe birleştirilebilirler. Yapı Taşları birlikte çalışabilir, yeniden kullanılabilir ve uygulamadan bağımsız: GovStack şunları tanımlar: özellikleryazılım değil.

2025 yılında lansmanı ile GovSpec'ler 2.0 (2025-2027 stratejisi) GovStack, yeni yapı taşlarını entegre ederek, birlikte çalışabilirlik özelliklerini güncelleyerek ve Çok fazla dijital kapasiteye sahip ülkeleri destekleyecek kademeli bir olgunluk modeli farklı. 20'den fazla ülke aktif olarak GovStack yaklaşımını kullanıyor.

Ne Öğreneceksiniz

  • GovStack'in 9 Temel Yapı Taşı ve teknik özellikleri
  • Mevcut İtalyan PA hizmetleri (SPID, CIE, pagoPA) GovStack Yapı Taşlarına nasıl eşlenir?
  • GovStack referans mimarisi: katmanlı model ve entegrasyon veri yolu
  • GovSpecs 2.0: 2025-2027 stratejisindeki yenilikler
  • OpenID Connect ile Yapı Taşı Kimliğinin pratik uygulaması
  • Yapı Taşı Ödemeleri: ulusal ödeme sistemleriyle entegrasyon
  • Rıza Yapı Taşı: GDPR uyumlu izin yönetimi
  • GovStack'in bağlamınız için doğru olup olmadığı nasıl değerlendirilir?

9 Temel Yapı Taşı

GovStack, aşağıdakileri kapsayan 9 temel yapı taşını (yeni 2025 spesifikasyonunda yayınlanmıştır) tanımlar: Herhangi bir dijital devlet hizmeti için gerekli çapraz işlevler:

Yapı Bloğu İşlev Protokoller / Standartlar İtalyan örneği
Kimlik Kimlik doğrulama ve kimlik yönetimi OIDC, SAML, W3C DID SPID, CIE, EUDI Cüzdanı
Ödemeler Ödemelerin ve transferlerin işlenmesi ISO 20022, REST API'si ödemePA
Onay Onayların toplanması ve yönetimi GDPR, DPIA, OAuth kapsamları Tasarım Yoluyla GDPR ile CMP
Dijital Kayıtlar Yetkili kayıtların yönetimi (sicil dairesi, tapu sicili) REST API, FHIR, CKAN ANPR, tapu sicili, meslek sicili
Mesajlaşma Hükümet ve vatandaşlar arasında güvenli iletişim SMTP, Push, WebSocket, MQTT IO Uygulaması, PEC, pagoPA bildirimleri
Bilgi Aracılığı Sistemler arasında güvenli veri alışverişi X-Road, REST, GraphQL PDND, AgID Birlikte Çalışabilirliği
Kayıt Kişilerin/kurumların hizmetler için kaydı REST API, OAuth 2.0 INPS portalı, SUAP, belediye portalları
Zamanlayıcı Randevu ve rezervasyonların yönetimi iCalendar, REST API'si Sağlık CUP, dijital sayaç
İş akışı Süreç ve prosedürlerin orkestrasyonu BPMN, SAGA modeli, REST PA uygulama yönetim sistemleri

GovStack Referans Mimarisi

GovStack, Yapı Taşlarının katmanlara yerleştirildiği katmanlı bir mimari önerir açık sorumluluklarla öne çıkıyor:

  • Katman 0 - Altyapı: bulut, ağ, güvenlik. BB'ler belirli bir buluta bağımlı değildir; AWS, Azure, GCP veya şirket içi altyapı üzerinde çalışabilirler.
  • Katman 1 - Çekirdek Yapı Taşları: 9 temel BB. Bunlar, ortaya çıkan otonom hizmetlerdir. Standartlaştırılmış RESTful API'leri. Her BB'nin genel bir spesifikasyonu vardır (OpenAPI + JSON şemaları).
  • Katman 2 - Paylaşılan Hizmetler: merkezi günlük kaydı, hizmet ağı gibi çapraz hizmetler, API ağ geçidi, hizmet keşfi. Bu hizmetler tüm BB'leri desteklemektedir.
  • Katman 3 - Uygulamalar: gerçek dijital hizmetler (okula kayıt, temel BB'leri düzenleyen sertifika talebi, damga vergisi ödemesi). 
# Architettura di un servizio PA con Building Block GovStack
# Esempio: Servizio di iscrizione scolastica online

# Il servizio orchestra 5 Building Block:
# 1. Identity BB - autenticazione genitore con SPID/CIE
# 2. Registration BB - raccolta dati del bambino
# 3. Digital Registries BB - verifica iscrizione anagrafica
# 4. Consent BB - consenso al trattamento dati minori
# 5. Messaging BB - conferma iscrizione via IO App/email
# 6. Payments BB - pagamento tassa iscrizione via pagoPA

from dataclasses import dataclass
from typing import Optional
import httpx

@dataclass
class SchoolEnrollmentRequest:
    parent_session_token: str   # Token da Identity BB (SPID/CIE)
    child_fiscal_code: str
    school_code: str
    year: int

class SchoolEnrollmentService:
    """
    Servizio iscrizione scolastica che orchestra i Building Block GovStack.
    Pattern: Saga orchestrator (gestione stati distribuiti con compensazioni).
    """

    def __init__(
        self,
        identity_bb_url: str,
        registry_bb_url: str,
        consent_bb_url: str,
        messaging_bb_url: str,
        payments_bb_url: str
    ):
        self.identity_url = identity_bb_url
        self.registry_url = registry_bb_url
        self.consent_url = consent_bb_url
        self.messaging_url = messaging_bb_url
        self.payments_url = payments_bb_url

    async def process_enrollment(self, request: SchoolEnrollmentRequest) -> dict:
        """
        Saga: processo iscrizione con compensazioni in caso di errore.
        Ogni step è idempotente e reversibile.
        """
        saga_log = []

        try:
            # Step 1: Verifica identità genitore tramite Identity BB
            parent_identity = await self._verify_parent_identity(
                request.parent_session_token
            )
            saga_log.append({"step": "identity_verified", "status": "ok"})

            # Step 2: Verifica residenza bambino tramite Digital Registries BB
            child_registry = await self._verify_child_in_registry(
                request.child_fiscal_code,
                parent_identity["fiscal_number"]
            )
            saga_log.append({"step": "registry_verified", "status": "ok"})

            # Step 3: Raccolta consenso GDPR tramite Consent BB
            consent_id = await self._collect_consent(
                parent_identity["fiscal_number"],
                purpose="school_enrollment_data_processing"
            )
            saga_log.append({"step": "consent_collected", "consent_id": consent_id})

            # Step 4: Registrazione iscrizione tramite Registration BB
            enrollment_id = await self._register_enrollment(
                child_fc=request.child_fiscal_code,
                school_code=request.school_code,
                year=request.year,
                parent_fc=parent_identity["fiscal_number"]
            )
            saga_log.append({"step": "enrollment_registered", "enrollment_id": enrollment_id})

            # Step 5: Pagamento tassa (se prevista) tramite Payments BB
            payment_url = await self._create_payment(
                parent_fc=parent_identity["fiscal_number"],
                enrollment_id=enrollment_id,
                amount_cents=1500  # 15 euro
            )
            saga_log.append({"step": "payment_created", "payment_url": payment_url})

            # Step 6: Notifica conferma tramite Messaging BB
            await self._send_confirmation(
                parent_fc=parent_identity["fiscal_number"],
                enrollment_id=enrollment_id,
                payment_url=payment_url
            )
            saga_log.append({"step": "notification_sent", "status": "ok"})

            return {
                "status": "success",
                "enrollment_id": enrollment_id,
                "payment_url": payment_url,
                "saga_log": saga_log
            }

        except Exception as e:
            # Compensazione: rollback degli step completati in ordine inverso
            await self._compensate(saga_log, e)
            raise

    async def _verify_parent_identity(self, session_token: str) -> dict:
        """Chiama il Building Block Identity per validare il token SPID/CIE."""
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{self.identity_url}/v1/tokens/validate",
                json={"token": session_token}
            )
            response.raise_for_status()
            return response.json()  # Returns: fiscal_number, name, surname, etc.

    async def _verify_child_in_registry(self, child_fc: str, parent_fc: str) -> dict:
        """Chiama il Building Block Digital Registries per verificare l'anagrafe."""
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"{self.registry_url}/v1/citizens/{child_fc}/family-relations",
                params={"parent_fiscal_code": parent_fc}
            )
            response.raise_for_status()
            return response.json()

    async def _collect_consent(self, parent_fc: str, purpose: str) -> str:
        """Registra il consenso tramite il Building Block Consent."""
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{self.consent_url}/v1/consents",
                json={
                    "citizen_pseudonym": self._pseudonymize(parent_fc),
                    "purpose": purpose,
                    "legal_basis": "GDPR Art. 6(1)(e)",
                    "version": "2025-01"
                }
            )
            response.raise_for_status()
            return response.json()["consent_id"]

    async def _compensate(self, saga_log: list, error: Exception):
        """
        Compensazione Saga: rollback in ordine inverso degli step completati.
        Garantisce consistenza anche in caso di errori parziali.
        """
        for step in reversed(saga_log):
            try:
                if step["step"] == "consent_collected":
                    await self._revoke_consent(step["consent_id"])
                elif step["step"] == "enrollment_registered":
                    await self._cancel_enrollment(step["enrollment_id"])
            except Exception as compensation_error:
                # Logga l'errore di compensazione ma continua
                print(f"Compensation error for {step['step']}: {compensation_error}")

    def _pseudonymize(self, fiscal_code: str) -> str:
        import hashlib, hmac
        key = b"secret-vault-key"  # In produzione: usa un HSM
        return hmac.new(key, fiscal_code.encode(), hashlib.sha256).hexdigest()[:32]

GovSpecs 2.0: 2025-2027 Stratejisindeki Yenilikler

GovSpec'ler 2.0GovStack tarafından 2025 yılında duyurulan, karşılaştırıldığında önemli güncellemeler sunuyor spesifikasyonların önceki versiyonuna:

  • 4 seviyeli olgunluk modeli: "Başlangıç aşaması"ndan (yalnızca eğitim ve mimari) yüksek seviye) "Gelişmiş Entegrasyon"a (ulusal birlikte çalışabilirlik çerçevelerine entegre edilmiş birden fazla BB). Bu, ülkelerin GovStack'i kendi önceliklerine ve yeteneklerine göre benimsemelerine olanak tanır.
  • Doğrulanabilir Kimlik Bilgileri Desteği: Building Block Identity artık şu özellikleri içeriyor: W3C Doğrulanabilir Kimlik Bilgileri, eIDAS 2.0 ve Avrupa EUDI Cüzdan programıyla uyumludur.
  • BB'ye: AI bileşenlerinin entegrasyonu için yeni bir Yapı Taşı (dil modelleri, devlet hizmetlerinde şeffaflık ve açıklanabilirliğe dikkat ederek tahmin, sınıflandırma).
  • OpenAPI 3.1 spesifikasyonları: Tüm BB API'leri artık OpenAPI 3.1 ile belgelenmiştir. SwaggerUI aracılığıyla JSON şemalarını ve test edilebilir örnekleri tamamlayın.
  • Uygunluk testi: Bir uygulamanın doğrulandığını doğrulamak için otomatik bir çerçeve BB, GovStack özelliklerine uygundur.

OIDC ile Yapı Taşı Kimliğinin Uygulanması

Yapı Taşı Kimliği en kritik ve uygulanması en karmaşık olanıdır. GovStack aşağıdaki API'leri açığa çıkarması gerektiğini belirtir: 

# Building Block Identity - Implementazione minima conforme GovStack
# OpenAPI 3.1 compatible - FastAPI implementation

from fastapi import FastAPI, HTTPException, Header, Depends
from fastapi.security import HTTPBearer
from pydantic import BaseModel
from typing import Optional
import jwt

app = FastAPI(
    title="Identity Building Block",
    description="GovStack Identity BB - Conforme a GovSpecs 2.0",
    version="2.0.0"
)

security = HTTPBearer()

# --- Modelli ---

class TokenValidationRequest(BaseModel):
    token: str
    expected_acr: Optional[str] = None  # Livello autenticazione richiesto

class IdentityResponse(BaseModel):
    sub: str                    # Identificativo presso l'IdP
    fiscal_number: Optional[str] = None  # Codice Fiscale (SPID/CIE)
    given_name: str
    family_name: str
    birthdate: Optional[str] = None
    acr: str                    # Livello autenticazione effettivo
    auth_time: int              # Timestamp autenticazione
    session_valid_until: int    # Scadenza sessione

class SessionCreationRequest(BaseModel):
    idp_id: str                 # Identity Provider scelto dall'utente
    redirect_uri: str
    acr_values: str = "https://www.spid.gov.it/SpidL2"
    scope: list = ["openid", "profile"]
    ui_locales: str = "it"

# --- Endpoints del Building Block Identity ---

@app.post("/v1/sessions",
    summary="Avvia sessione di autenticazione",
    tags=["Sessions"],
    response_model=dict)
async def create_authentication_session(request: SessionCreationRequest) -> dict:
    """
    GovStack Identity BB - Avvia il flusso di autenticazione.
    Restituisce l'URL di redirect verso l'IdP.
    """
    # Genera state e nonce per sicurezza
    import secrets
    session_id = secrets.token_urlsafe(32)
    state = secrets.token_urlsafe(32)
    nonce = secrets.token_urlsafe(32)

    # Recupera metadata dell'IdP dalla federazione OIDC
    idp_metadata = await get_idp_metadata(request.idp_id)

    # Costruisce URL autorizzazione (PKCE + Request Object)
    auth_url = build_oidc_auth_url(
        idp_auth_endpoint=idp_metadata["authorization_endpoint"],
        client_id=CLIENT_ID,
        redirect_uri=request.redirect_uri,
        scope=request.scope,
        state=state,
        nonce=nonce,
        acr_values=request.acr_values,
        private_key=SIGNING_KEY
    )

    # Salva sessione (Redis o DB)
    await session_store.save(session_id, {
        "state": state, "nonce": nonce, "idp_id": request.idp_id
    })

    return {"session_id": session_id, "authorization_url": auth_url}

@app.post("/v1/tokens/validate",
    summary="Valida un token di sessione",
    tags=["Tokens"],
    response_model=IdentityResponse)
async def validate_token(request: TokenValidationRequest) -> IdentityResponse:
    """
    GovStack Identity BB - Valida un token e restituisce l'identità.
    I servizi chiamanti usano questo endpoint per verificare l'autenticazione.
    """
    try:
        # Decodifica e valida il token (firma, scadenza, audience)
        claims = jwt.decode(
            request.token,
            JWKS,
            algorithms=["RS256"],
            audience=CLIENT_ID
        )

        # Verifica livello autenticazione se richiesto
        if request.expected_acr:
            actual_acr = claims.get("acr", "")
            if not _meets_acr_requirement(actual_acr, request.expected_acr):
                raise HTTPException(
                    status_code=403,
                    detail=f"Insufficient authentication level. Required: {request.expected_acr}"
                )

        return IdentityResponse(
            sub=claims["sub"],
            fiscal_number=claims.get("fiscal_number"),
            given_name=claims["given_name"],
            family_name=claims["family_name"],
            birthdate=claims.get("birthdate"),
            acr=claims.get("acr", ""),
            auth_time=claims.get("auth_time", 0),
            session_valid_until=claims.get("exp", 0)
        )
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.InvalidTokenError as e:
        raise HTTPException(status_code=401, detail=f"Invalid token: {str(e)}")

@app.delete("/v1/sessions/{session_id}",
    summary="Termina sessione (logout)",
    tags=["Sessions"])
async def end_session(session_id: str) -> dict:
    """
    GovStack Identity BB - Logout con propagazione verso l'IdP.
    Implementa OIDC Back-Channel Logout per notificare tutti i RP attivi.
    """
    session = await session_store.get(session_id)
    if not session:
        raise HTTPException(status_code=404, detail="Session not found")

    # Notifica logout all'IdP (OIDC Back-Channel Logout)
    idp_metadata = await get_idp_metadata(session["idp_id"])
    if "end_session_endpoint" in idp_metadata:
        await propagate_logout(idp_metadata["end_session_endpoint"], session)

    await session_store.delete(session_id)
    return {"status": "session_terminated"}

def _meets_acr_requirement(actual: str, required: str) -> bool:
    """Verifica che il livello di autenticazione effettivo soddisfi il requisito."""
    ACR_LEVELS = {
        "https://www.spid.gov.it/SpidL1": 1,
        "https://www.spid.gov.it/SpidL2": 2,
        "https://www.spid.gov.it/SpidL3": 3,
        "https://www.cie.gov.it/cie/aa": 2,
    }
    return ACR_LEVELS.get(actual, 0) >= ACR_LEVELS.get(required, 0)

Yapı Taşı Mesajlaşma: IO Uygulaması ve Hükümet Bildirimleri

Building Block Messaging, hükümet ve vatandaşlar arasındaki iletişimi yönetir. İtalya'da servis GovStack Messaging spesifikasyonuyla daha uyumlu Ben Uygulaması (io.italia.it), PagoPA S.p.A tarafından yönetilen, PA ile iletişim için ulusal uygulama. 

# Building Block Messaging - Integrazione con IO App
# API REST di IO App per invio messaggi ai cittadini

import httpx
from pydantic import BaseModel
from typing import Optional

class IOMessage(BaseModel):
    fiscal_code: str           # Codice Fiscale del destinatario
    time_to_live: int = 3600  # Secondi di validità notifica push
    content: dict              # Contenuto del messaggio
    default_addresses: Optional[dict] = None  # Fallback email

class IOAppClient:
    """
    Client per le API di IO App.
    Le API IO App sono disponibili su https://developer.io.italia.it
    """

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.io.italia.it/api/v1"

    async def send_message(self, message: IOMessage) -> dict:
        """
        Invia un messaggio a un cittadino tramite IO App.
        Il cittadino deve aver attivato il proprio profilo IO.
        """
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{self.base_url}/messages",
                headers={
                    "Ocp-Apim-Subscription-Key": self.api_key,
                    "Content-Type": "application/json"
                },
                json={
                    "fiscal_code": message.fiscal_code,
                    "time_to_live": message.time_to_live,
                    "content": message.content,
                    "default_addresses": message.default_addresses
                }
            )
            response.raise_for_status()
            return response.json()

    async def check_profile(self, fiscal_code: str) -> bool:
        """
        Verifica se un cittadino ha attivato il profilo IO e accetta messaggi dalla PA.
        """
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"{self.base_url}/profiles/{fiscal_code}",
                headers={"Ocp-Apim-Subscription-Key": self.api_key}
            )
            if response.status_code == 404:
                return False
            response.raise_for_status()
            profile = response.json()
            return profile.get("sender_allowed", False)

# Utilizzo: notifica iscrizione scolastica
async def notify_enrollment(fiscal_code: str, enrollment_id: str, payment_url: str):
    io_client = IOAppClient(api_key="your-io-api-key")

    # Verifica se il cittadino usa IO App
    has_io = await io_client.check_profile(fiscal_code)

    if has_io:
        # Messaggio strutturato IO App con CTA pagamento
        message = IOMessage(
            fiscal_code=fiscal_code,
            content={
                "subject": f"Iscrizione Scolastica {enrollment_id} - Conferma",
                "markdown": f"""
## La tua iscrizione è stata registrata

L'iscrizione con codice **{enrollment_id}** è stata registrata con successo.

Per completare la procedura, effettua il pagamento della tassa di iscrizione tramite il
link qui sotto.

**Importo**: 15,00 €

[Paga ora]({payment_url})

Per assistenza: [Ufficio Scolastico](https://istruzione.comune.esempio.it)
""",
                "payment_data": {
                    "amount": 1500,
                    "notice_number": enrollment_id,
                    "payee": {
                        "fiscal_code": "COMUNE_FC",
                        "name": "Comune di Esempio"
                    }
                }
            },
            default_addresses={"email": None}  # No fallback email
        )
        await io_client.send_message(message)
    else:
        # Fallback: email tradizionale (da implementare)
        await send_email_notification(fiscal_code, enrollment_id, payment_url)

İtalyan Ekosistemindeki GovStack haritası

İtalya, doğal olarak GovStack Yapı Taşlarıyla eşleşen gelişmiş bir KKD ekosistemine sahiptir. İtalyan bir geliştirici için GovStack'ı benimsemek sıfırdan başlamak anlamına gelmiyor: Mevcut entegrasyonları standartlaştırılmış modüler bir modele göre yeniden düzenlemek.

BB GovStack İtalyan uygulaması Olgunluk Düzeyi Doldurulacak boşluk
Kimlik SPID, CIE, eIDAS Yüksek (seviye 3-4) Tam OIDC birleştirme, EUDI Cüzdanı
Ödemeler ödemePA Yüksek (seviye 4) GPD REST API'yi tamamlayın
Mesajlaşma IO Uygulaması, PEC Yüksek (seviye 3) IO Uygulama Penetrasyonu (bazı bölgelerde hala düşük)
Dijital Kayıtlar ANPR, tapu sicili, PDND Orta (seviye 2-3) Kayıtlar arasındaki birlikte çalışabilirlik hala kısmi
Bilgi Aracılığı PDND Orta (seviye 2) PDND'nin benimsenmesi hala artıyor
Onay Çeşitli (standartlaştırılmamış) Düşük (seviye 1) Merkezi bir fikir birliği platformuna ihtiyacımız var
Zamanlayıcı Bölgesel sağlık CUP Düşük-Orta (seviye 1-2) Bölgesel parçalanma; ulusal standart yok
İş akışı PA uygulama sistemleri (heterojen) Düşük (seviye 1) Büyük heterojenlik; standardizasyona ihtiyaç var

GovStack Ne Zaman Kabul Edilmeli?

GovStack özellikle şu durumlarda uygundur:

  • Bir şey inşa ediyorsun yeni PA dijital hizmeti sıfırdan başlıyor ve satıcı bağımlılıklarından kaçınmak istiyorsanız
  • Mevcut sistemleri entegre etmeniz ve ortak bir referans mimari modeli istemeniz gerekiyor
  • Bir bağlamda faaliyet gösteriyorsunuz çok ülkeli (uluslararası işbirliği, sınır ötesi hizmetler)
  • GovStack açık kaynak ekosistemine katkıda bulunmak ve diğer ülkelerin uygulamalarından faydalanmak istiyorsunuz

GovStack, İtalyan bağlamı için çok özel hizmetleriniz olduğunda, sistemler mevcut olanlar (SPID, pagoPA), ek soyutlama yükü olmadan gereksinimlerinizi zaten karşılıyor, veya dağıtılmış bir federasyonun karmaşıklığını yönetmek için sınırlı kaynaklara sahip olduğunuzda.

Sonuç: Perspektiften GovTech Serisi

Bu makale, kamu yönetiminin dijitalleşmesine adanmış GovTech serisini sonlandırıyor. Kamu dijital altyapısından (DPI) kimliğe kadar ekosistemin tamamını keşfettik Avrupa Birliği (eIDAS 2.0, EUDI Cüzdan), SPID ve CIE'nin somut uygulanmasından veri korumasına kadar (Tasarım Yoluyla GDPR), erişilebilirlikten (WCAG 2.1 AA) açık verilere (DCAT-AP_IT, CKAN) kadar uluslararası modüler çerçeveler (GovStack).

Ortak nokta her zaman aynıdır: Kamuya açık dijital hizmetler kapsayıcı, güvenli, birlikte çalışabilir ve tekrar kullanılabilir. GovStack, standartlaştırılmış Yapı Taşlarıyla şunları sağlar: Bu hedeflere küresel ölçekte ulaşmak için ortak bir kelime dağarcığı ve ortak bir mimari model.

GovTech Serisinin tamamı

  • #00: Dijital Kamu Altyapısı - Mimari ve Yapı Taşı
  • #01: eIDAS 2.0 ve EUDI Cüzdan - Geliştirici Kılavuzu
  • #02: Devlet Kimliği için OpenID Connect
  • #03: Açık Veri API Tasarımı - Genel Verileri Yayınlayın ve Tüketin
  • #04: GDPR-by-Design - Kamu Hizmetlerine Yönelik Mimari Desenler
  • #05: PA - WCAG 2.1 AA uygulaması için erişilebilir kullanıcı arayüzü
  • #06: Devlet API Entegrasyonu - SPID, CIE ve BT Dijital Hizmetleri
  • #07: GovStack Yapı Taşı - (bu makale)