Software Architect · Data Platform Engineer

Emre
Gülay.

Architecting software without black boxes—transparent to understand, effortless to scale, and secure by design.

Software architect and data platform engineer with more than twenty years of experience across enterprise software, distributed systems and modern data platforms. I favour practical engineering over unnecessary complexity, and treat security, maintainability and operability as architectural decisions rather than later additions.

View projects GitHub

01 // philosophy

Engineering philosophy

01

Designed to be maintained

The first release is the cheapest part of a system's life. Structure, naming and boundaries are chosen so the architecture can still be read, reasoned about and changed years later, without depending on the memory of whoever built it.

02

Understandable beats clever

An architecture that can be explained simply can also be scaled, secured and changed deliberately. Complexity that does not pay for itself is a cost, so practical engineering wins over unnecessary complexity.

03

Security is decided at the drawing board

Trust boundaries, least-privilege access and data protection are part of the architecture, not a checklist applied before go-live. Secrets belong in a secret store, never in code or configuration.

04

Control stays with the owner

Data lives on infrastructure its owner controls. Whether a system runs on a laptop, a private cluster or a public cloud, and which vendor or model it talks to, is a deployment choice rather than something the architecture imposes.

05

Governed, validated, repeatable

Anything that touches production data is validated before it runs, repeatable when it runs again and traceable afterwards. Arbitrary generated code and one-off manual actions do not belong on that path.

06

Verification is automated

Repetitive engineering and verification work is automated so it happens on every change rather than on request. Tests run against real databases and services, not imitations of them.

07

AI in proportion

A language model is a component within a larger system, not the system itself. It belongs in the parts of a process that genuinely benefit from non-deterministic reasoning, with deterministic code deciding what actually happens.

08

Built for the world as it is

Real data arrives inconsistent, real environments are constrained, and real systems have to be installed, reconfigured and operated long after the design discussions are over. Software that only works in the ideal case is not finished.

09

Show the work

A complete, working implementation argues for an approach better than any document. I publish production-inspired reference implementations rather than fragments, so that engineers, architects and platform teams can see how the pieces fit together.

areas of interest

stack

Languages
Frameworks & Platforms
Data
Identity, Security & AI
Infrastructure
Testing & Quality

02 // projects

Reference implementations

Production-inspired reference implementations. The principles stay constant; the approach is chosen per problem.

01

private

Kozmik Lahmacun

A governed conversational analytics and machine-learning platform for non-technical business users.

Translates natural-language requests into validated, versioned execution orders for trusted Apache Spark processing. Corporate datasets stay inside the controlled execution environment and are never processed by the LLM, which works only with authorised metadata and bounded result facts.

  • No arbitrary SQL, generated Python or executable code ever reaches the data plane
  • Natural-language reporting and predictive modelling with automatic algorithm comparison, in English and Turkish
  • Results open as bilingual starter notebooks in the corporate Jupyter environment over short-lived presigned links
  • Role-based, owner-scoped workspaces with an immutable audit trail
  • Keycloak identity with AD/LDAP federation; Kafka, object-event and CSV intake into append-only Parquet
  • One guided installer for a laptop evaluation or an air-gapped Kubernetes cluster, health-gated with an as-built record
Spring BootPySparkSvelteKitPostgreSQLKafkaMinIORedisKeycloakVaultJupyterLabHelm

Proprietary · private

02

0

Schema Serpent

An AI-powered Spring Boot service that maps messy vendor price files into PostgreSQL and exposes governed reporting through MCP.

Every vendor describes the same data with different column names, units, currencies and file formats. Schema Serpent sends only a small preview to an LLM, which proposes a deterministic transformation scenario; Java validates, dry-runs and executes it locally, keeping every import auditable, repeatable and cheap.

  • AI maps once, Java executes forever: scenarios are validated, dry-run and replayed deterministically
  • Watches an import directory for CSV, TSV, XLS and XLSX with chunked, concurrent, resumable ingestion
  • Full price history converted to TRY using dated historical TCMB exchange-rate bulletins
  • Ten parameterised MCP tools usable directly from Claude Desktop, no raw SQL
  • Works with local LLMs via LM Studio or OpenAI-compatible APIs
JavaSpring BootPostgreSQLMCPLM Studio

PolyForm Noncommercial 1.0.0

03 · on Google Play

private

Dark Journal

A private, encrypted Android diary where one of the seventy-two spirits of the Ars Goetia answers a sealed entry, in words from an LLM that runs on the phone.

Entries are sealed with AES-256-GCM under a key that exists only on the device and as a 24-word recovery phrase. When an entry is sealed, a small on-device model reads its feeling and themes; code narrows it to the spirits whose courts and offices fit that reading, and the model picks one and speaks in that spirit's voice, from character profiles checked against the old grimoires. Nothing the user writes leaves the phone, except as an encrypted backup they choose to make.

  • The model reads the entry, code narrows the spirits to those whose offices fit, the model picks one, and it answers fully in its own character, from a profile checked against the old books
  • On-device inference with Gemma 4 E2B through LiteRT-LM; no accounts, no analytics, and a server only for answers a user reports
  • A 2.6 GB model download that resumes with HTTP range requests and survives the phone stopping the app in the background, rebuilt from closed-test feedback
  • AES-256-GCM vault with a keystore-wrapped key and a BIP-39 recovery phrase
  • Encrypted backup to any place the user picks through Android's own file picker, Google Drive included, with no OAuth and no cloud project
  • English and Turkish throughout, including the spirits' answers
  • A monochrome, motion-led interface where every element assembles and nothing simply appears
FlutterDartKotlinGemma 4 E2BLiteRT-LMAES-GCMAndroid Keystore

Proprietary · private

04

1

Kebab Storm

A secure distributed ETL framework for Apache Spark.

Schema-driven data processing for large-scale analytics that protects sensitive information end to end. Sensitive fields are encrypted inside the pipeline itself, not bolted on at the storage layer.

  • AES-256-GCM applied per field within distributed Spark processing
  • Declared schemas govern transformation and validation instead of ad-hoc pipeline code
  • HashiCorp Vault keeps cryptographic material out of code and configuration
  • Governed Apache Parquet output, structured for downstream processing
Apache SparkPythonApache ParquetVault

05

0

Helpdesk

A modern Spring Boot reference application demonstrating enterprise backend engineering practices.

A compact, production-inspired backend showing how contemporary Spring patterns fit together in one coherent codebase.

  • Three API styles over one domain model: REST, gRPC and Model Context Protocol served side by side, the REST API described by an OpenAPI specification
  • Spring AI integrated as a scoped capability, not as the architecture
  • Testcontainers-backed integration tests against real PostgreSQL with Vault-managed secrets
Spring BootSpring AIgRPCMCPPostgreSQLVaultTestcontainers

06

0

kebab.nvim

A lightweight IDE layer for LazyVim, built so a full graphical IDE is no longer needed for day-to-day work — without giving up the terminal.

It is a plugin spec collection, not a Neovim distribution: LazyVim stays in charge, and kebab.nvim adds the IDE on top. Language servers, debuggers, test runners and formatters are installed automatically through Mason, and everything the layer knows about a language is declared in one file.

  • One file per language: adding a language is adding a file, and a user can add or override one from their own config without touching the repo
  • Spring Boot application.yml completion against your own beans; Flutter device picker, emulator launch and hot reload
  • Add a dependency and generate code the way a graphical IDE does, without leaving the editor
  • SQL over JDBC with saved connections, a table browser and completion that knows tables and columns; nine databases, and a password is never stored
  • Read-only semantic queries for a script or an AI agent: diagnostics, definitions, references, symbols and hover, and nothing writes to the working tree
  • Right-click menus where every entry shows its keybinding, so the menu teaches the shortcut
LuaNeovimLazyVimMasonJavaJDBCBash

MIT

03 // contact

Get in touch

For conversations about architecture, data platforms or engineering practice, email is the most reliable way to reach me.

emre@gulay.io GitHub LinkedIn · on request X