Skip to content
Muhammet Şafak
tr

Expertise

Backend developer: the queue, the database and the server behind the API

Work moved onto a queue does not become durable by itself; I am a backend developer who designs the contract, the queue, the database and the server together.

years
16

Backend development, for me, is not a language but a boundary of responsibility: everything behind the screen the user sees. Contract, queue, database and server are four faces of the same work, and a decision about one binds the other three.

I start from the API contract: the response shape, the error contract and versioning are settled before code is written. Once work moves onto a queue, writing and publishing are two separate systems with no atomicity between them; I close that gap with a transactional outbox and idempotent consumers. On the database I decide indexes by reading the query plan, not by instinct.

On the server side my scope stays at application level: packaging the environment with Docker, building the test and deploy pipeline with GitHub Actions, configuring the layer in front of the application with nginx. Infrastructure as an architectural subject I write about in the Engineering section.

What is a backend developer?

A backend developer designs and builds the server-side software that runs behind the screen the user sees. APIs, the database, queues and background jobs, authentication and integrations with outside systems are their ground; whatever the front end shows, they are responsible for the data being processed correctly, consistently and on time.

What does a backend developer do?

The day-to-day work is defining the API contract, modelling data and tuning queries, moving slow or critical work onto a queue, planning for failure and repetition up front, and packaging the application with its environment and shipping it. I do this by starting from the contract, measuring queue and database decisions, and on the server side working at application level with Docker, nginx and GitHub Actions.

Recent writing in this area

64 goroutines on four cores: Mutex is 1.40 times faster than a one-way channel, but its p99 is four times higher

When G goroutines on P cores hammer the same shared counter, how many operations a second do sync.Mutex, an owner-goroutine channel and a buffered channel manage, and how do tail latency and fairness of waiting change?

Finding

With 64 goroutines on four cores, sync.Mutex is 1.40 times faster than a one-way channel (10.46 and 7.47 million operations/s) but its p99 wait is 4.00 times higher (294,911 and 73,727 ns). On eight cores the Mutex ranges from 16.27 to 26.25 million operations/s across the two runs (a bimodal cell); the one-way channel holds at 7.31 and 7.32 million. More than half of the cells are flagged in both runs; confidence is low.

measured 30 days ago

Low confidence

Technologies I pair it with

  • RabbitMQ

    Asynchronous delivery between services; the exit door of the outbox relay.

  • Redis

    Cache, counters and short-lived locks.

  • PostgreSQL

    The database I measured queue-table and index behaviour on.

  • MySQL

    The relational store I have worked with longest.

  • Elasticsearch

    Where relational stops being enough: full-text search and log analysis.

  • Docker

    Development environment and deployment unit.

  • nginx

    The layer in front of the application.

  • GitHub Actions

    Test and deploy pipeline; the steps that SSH into the server live here.

Frequently asked

8 questions

  • What does a backend developer do?

    They build the side the user does not see: APIs, the database model, queues and background jobs, authentication and integrations with outside systems. The data the front end shows being correct and consistent is this side's responsibility.

  • How long have you worked on the backend?

    Since 2010, so 16 years.

  • What is the difference between backend and frontend?

    Frontend covers the interface the user sees and touches; backend covers the data, business rules and server behaviour behind it. The two talk through the API contract, and when the contract is unclear each side has to guess the other's assumptions.

  • Where do you start when designing an API?

    With the contract. If the response shape, the error contract and the versioning decision are not settled before code is written, every client team writes its own assumption instead.

  • Does using a queue guarantee delivery?

    No. A transactional outbox stops messages from being lost, but what it gives you is at-least-once; the message can repeat. What completes the guarantee is not the queue; it is an idempotent consumer.

  • How do you make index decisions?

    By looking at how the query actually behaves instead of what sounds fast. I check the plan on realistic data volume, because an index that looked right can stop helping as the table grows.

  • Which database and queue technologies do you work with?

    RabbitMQ for queues, PostgreSQL and MySQL as relational stores, Redis for caching, Elasticsearch for full-text search and log analysis. The full list is in the Technologies section of this page.

  • Do you set up the server side too?

    Yes, at application level. I set up the environment with Docker, the deploy pipeline with GitHub Actions and nginx in front. Infrastructure as an architectural subject is written in the Engineering section.

Let us work together

If you have work in this ecosystem, tell me what you are building and we will talk about how to build it.

Search the site

Start typing to search posts, projects and pages.

Esc to close Powered by Pagefind