Salih Karagöllü

An expenditure’s detail view loaded several independent document collections in a single query. Joining collections that don’t depend on each other returns one row for every combination, so the result grows with the product of their sizes, not the sum. Some expenditures have hundreds of related documents.

I split the fetch into one query per collection and assembled the object graph in a helper, with a separate path for callers that also need nested documents. The persistence context maps every result back onto the same entities, so callers still get one complete graph.

• In batch payment validation I fixed the opposite problem: one query per payment order inside a loop. A fetch specification loads them with their parent, and a local check skips the remote validation call when there is nothing to validate.
• In a paginated list, putting the fetch on the pageable query broke paging, and an inner join hid records without an optional relation. Filtering and paging now stay in the base query, relations load separately, and the optional join is a left join.
• Repository tests flush and clear the persistence context before asserting with Hibernate.isInitialized. Otherwise entities left over from the test setup look loaded and a missing fetch passes.

A callback from another service occasionally never arrived, which left an employee’s record waiting indefinitely. While the underlying cause was being investigated, I added a recovery job.

• It runs on a single instance and can be switched off by a parameter.
• It uses its own Kafka consumer outside the main group, without auto-commit, so the main consumer’s offsets never move.
• It assigns partitions directly and seeks by timestamp to scan a bounded window, from two hours to thirty minutes before each run, so it never races fresh messages.
• Each event goes through the existing linking logic, which does nothing when the record is already linked and never overwrites a different link.

It contains the problem; it isn’t the fix for the root cause, and isn’t meant to be.

Some services logged Kafka poll timeouts, lost group membership and failed offset commits. It looked like a messaging problem. Reading the logs in order showed database read timeouts during updates first: the consumer was blocked on the database long enough to be removed from its group, and the Kafka errors followed.

I worked through the remaining hypotheses with infrastructure and network colleagues: row locks, dropped connections, a mismatched build, oversized updates. Two things I had to keep straight: missing rows during a long first attempt don’t prove a message was lost, and a read replica can’t tell you what happened on the primary. I also reverted a speculative entity change so the network team could reproduce the original behavior cleanly.

A set of historical relationship events between two services had apparently never been processed. Replaying all of them would have been easy and wrong: since then, some records had been relinked, cancelled or paid, and an old event could undo a valid current state.

I worked out the side effects of each event type and wrote a read-only SQL classification over message content, consume times, current relations, cancellations and payment history, including possible message-ID collisions. Each of the 33 events got a verdict someone else could check before anything was republished.

Compressing attachments in the browser worked locally and hung on every deployed environment. I compared the conversion code, browser profiles, library versions, callback order and memory copies before finding the actual cause.

A script the compression library loads at runtime was served from the wrong path in the Nginx configuration. The local dev server served it correctly, which hid the problem. The fix was one line in each of three environments.

A shared library acknowledges a Kafka message once the listener method returns. With nested transaction interception, “returned” can come before the outer transaction physically commits, so a message can be acknowledged while its data is still at risk.

I traced the Spring proxy and advice order and wrote reproduction tests for the rules the library has to follow: acknowledge only after the physical commit, never when the commit fails, and roll back before a negative acknowledgment.

A name search goes through a shared library and an outbound gateway before reaching an external service, and Turkish characters broke along the way. There were two separate problems: the query string wasn’t explicitly encoded as UTF-8, and the gateway built its JSON body as a string instead of serializing a typed request.

I fixed both and changed the contract tests to use Turkish characters. ASCII fixtures pass either way, which is how the bug got through.

A lookup by petition number checked that the user had the right role, but not that the record belonged to the user’s own public administration. In a system shared by many institutions, that difference matters.

I added a record-level check that loads the record’s administration and compares it with the user’s, and routed the alternate lookup paths through the same check. Separately, I narrowed which roles can see preliminary control opinions before a document is formally sent.

Payment orders need to reference tax-debt petitions that another service owns. I built the feature across both services and the client.

• A relationship table with Liquibase migrations.
• Secured service-to-service endpoints and query rules for eligible petitions: calculated, matching taxpayer identity, inside a 15-day validity window.
• A React search-and-select screen.
• An audit trail of every addition, update and removal.
• Adding or removing a petition is asynchronous, so the payment side keeps a pending state until the other service confirms.

Payment types were hard-coded as Java enums and JavaScript constants, so every regulatory change meant a deployment across several repositories.

I moved them into a table, migrated more than 150 existing records from string values to foreign keys, exposed the types through an endpoint, injected the lookup into the mapping layer and replaced the client’s static enum with a cached context. New payment types have since been added without a deployment.

A follow-up fixed lowercase codes arriving from upstream integrations with a Turkish-locale uppercase conversion, since a lowercase i doesn’t uppercase to I in Turkish.