National System Integrations

In many sectors, software cannot operate without connecting to mandatory public systems and national e-government platforms. These integrations have strict rules, frequently changing schemas and low-error-tolerance flows; we have real production experience on this demanding surface.

Talk to an expert

In Turkey, software doesn't run without connecting to an official system

A pharmacy can't sell a box without scanning its barcode. A clinic can't invoice without sending a Medula authorization, a hotel can't close a stay without reporting the guest to KBS, a lawyer can't follow a case file without connecting to UYAP. In many sectors in Turkey this is exactly where the software's job starts: without the system the regulation requires, the product simply doesn't stand up.

We didn't learn this from documentation. Medula, İTS and e-Nabız on the healthcare side; UYAP in law and accounting; KBS in hospitality; ÇKS in agriculture; SGK entitlement queries at optics and hearing centers; Amazon SP-API in logistics and retail — all of them run live today. Below we list which one runs in which sector.

Live integration with the mandatory official systems
We run the documentation and application process
Each system is an independent adapter — when one changes, the others don't stop
Sandbox access is requested while the project is still starting

A reader arm mounted over a long plain counter; its lamp is lit and reading the box beneath it, and a low hatch set into the counter has opened to let the box cross to the waiting figure with an outstretched hand, while further along the counter a second box still sits behind a closed hatch — Some work simply can't proceed unapproved — the box doesn't cross the counter unread.

What makes official-system integration hard

Documentation. Most systems' API docs aren't public; you need an institutional application, a contract and an approval.

The test environment is its own application — sandbox credentials usually arrive weeks later.

Schemas can change without notice: a field name, sometimes whether a field is required at all.

Error tolerance is low. A missing report gets rejected — in some systems it's tied straight to a penalty.

Authentication runs on an e-signature or a client certificate, and the certificate brings its own management burden.

When the regulation changes the integration changes with it — following that has to be someone's job.

The systems we run live

Each one runs inside a working installation in a different sector, today.

e-Government

Identity verification and e-signature-based approval; it sits at the entry layer of enterprise installations.

Medula

Authorization and invoicing flow — the daily work of our polyclinic software.

İTS (drug track-and-trace)

Drug barcode track-and-trace. On the pharmacy side it's the mandatory step before a sale.

e-Nabız (national health record)

The national health record; the shared connection point across our healthcare installations.

UYAP (judicial system)

Case, file and hearing data; it runs in the system we built for a law practice.

KBS (guest ID reporting)

Mandatory guest-ID reporting. In the hotel management system it's prepared together with the check-in record.

ÇKS (farmer registry)

Farmer-registry-ready data, on the agriculture side.

Amazon SP-API

Marketplace order and stock flow, in logistics and retail installations.

A single panel standing alone on bare white ground, its face carrying a row of keyholes each cut to a different shape; a figure fits the matching key into one of them, while a rack along the panel's top edge holds several keys already seated, each a different form — Every official system has its own mouth — each one takes a connector of its own shape.

The three disciplines living beneath an official integration

Documentation and the application process

Connecting to an official system starts with paperwork, not code: an authorization letter, a contract, sometimes an on-site inspection. This is measured in weeks, not days. Because we've been through it before, we know which document is asked for in which order — it doesn't show up later as a surprise in the timeline.

The letter and contract sequence is known in advance
The expected duration goes into the timeline from day one

A long counter lined with stamping windows; a figure carries one bundle of papers from window to window, at each window an arm presses a fresh seal onto it, and only after the last window does the clerk hand back a small key

Test environment and sandbox access

You don't walk straight into the live environment of most official services. Scenarios are run first with test credentials: success, failure and — the one most often skipped — timeout. Those credentials need their own application, so we request them in the first week; ask late and the development is ready while the environment isn't.

Sandbox credentials are requested in the first week
The timeout path gets tested too, not just the happy one

Two identical doors side by side in the same wall, one roped off with a barrier post; the large key in the figure's hand fits only that door, and through the open one the same room is seen — clean, empty and stocked with crates to practise on

Tracking version and schema changes

An official service's field name, required field or authentication method can change without notice. That's why every integration is written as an independent adapter: a change concerns only that adapter, and the rest of the application stays where it is. We follow the announcements and meet the change in the test environment first.

Every integration is an independent adapter
A change is met in the test environment before it reaches production

On a noticeboard the pinned sheet has just been replaced by a new one and the old sheet is fluttering to the floor; the small bell above the board has struck, and the figure holds both sheets side by side with an adapter part in their other hand

Which system runs where

Every line below comes from an installation that is in use today.

Polyclinic management

The Medula authorization and invoicing integration runs inside the daily flow.

Pharmacy management

Drug and product tracking via the İTS barcode; without a scan the sale doesn't move.

Optics & hearing center

SGK entitlement queries run here; e-Nabız is the shared connection point on the healthcare side.

Law & accounting practice

Connects to the profession's official backbone through UYAP case/file integration and filing services.

Hotel & hospitality (PMS)

A checked-in guest's ID is recorded in a form that's ready for the KBS report.

Farm operation

Produces exportable records ready for ÇKS and subsidy filing.

Logistics & retail

Orders are pulled through Amazon SP-API, with stock and price kept in sync.

A taut cable runs from a hand crank on the near side of a thick wall, through a sealed port; as the figure turns the crank, the heavy wheel on the far side turns in step with it, and a second figure stands where they can watch both at once — An integration isn't a diagram — turn the crank here and the wheel on the other side turns too.

How we build an official-system integration

Application & documentation

We know which document, contract and authorization will be needed; the application starts before any code is written.

End-to-end testing in sandbox

With the provider's test credentials we walk through success, failure and timeout together.

Writing it as an adapter

The integration isn't embedded in the core but becomes an independent module; when regulation changes, only that module is updated.

Go-live & monitoring

We roll out in a controlled way and wire error rate and schema changes into monitoring.

Version tracking & maintenance

We follow the changes the institution announces and keep the adapter current under SLA maintenance.

The technology we build on

Protocol

SOAP
REST
XML

Security

e-Signature
certificate
mTLS

Integration

Public-service adapters
monitoring & alerting

Backend

.NET 9
PostgreSQL

Adapter

Every official system is an independent module

Sandbox

A test environment before production, always

Layered

service / bll / dal architecture

.NET 9

Modern core stack

Frequently asked

Have you really connected to these systems, or did you just read the documentation?

The Medula, İTS, UYAP, KBS, ÇKS and Amazon SP-API integrations run inside installations in use today — in healthcare, law, hospitality, agriculture, logistics and retail. The part you can't learn from the documentation is the weeks spent in the test environment anyway.

How long does it take to get test-environment access?

It varies by institution; it can run from a few days to a few weeks. That's why we file the application at the very start of the project, before development begins.

What happens if the institution changes something?

Because every integration is written as an independent adapter, when a field name or a rule changes only that adapter is updated; the rest of the application is untouched. We follow the change announcements and verify them in the test environment before they reach production.

Which official system is mandatory in which sector?

Medula and İTS in healthcare, UYAP in law, KBS in hospitality and ÇKS in agriculture are generally mandatory; e-government and e-signature are used as an identity layer across many sectors. We work out together in the first conversation which ones are mandatory on your side.

Do you manage the e-signature/certificate process as well?

You obtain the certificate from an e-signature provider; we integrate it into the system and build the mTLS and signature-verification flow.

How long does it take for the system to go live?

It depends on scope; the general range is 3 weeks to 5 months. Documentation and test-environment time sit inside that timeline rather than being added later.

Which official system do you need to connect to?

Let's work out which system is mandatory in your sector and where to start. You don't have to sign anything at the end of the conversation.