Backend Engineering Roadmap

/* Minimal TCP server skeleton — illustrates accept loop */
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <string.h>

int main(void) {
    int srv = socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(srv, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(8080);
    addr.sin_addr.s_addr = INADDR_ANY;

    bind(srv, (struct sockaddr *)&addr, sizeof(addr));
    listen(srv, SOMAXCONN);   /* SOMAXCONN = OS backlog limit */

    while (1) {
        int client = accept(srv, NULL, NULL);  /* blocks until client connects */
        /* hand off: thread-per-request -> pthread_create()  */
        /*           event loop          -> epoll_ctl(ADD)   */
        close(client);
    }
}

/* user.proto — gRPC service definition */
// syntax = "proto3";
//
// service UserService {
//   rpc GetUser (GetUserRequest)  returns (UserResponse);          // unary
//   rpc WatchUser (GetUserRequest) returns (stream UserResponse);  // server-streaming
// }
//
// message GetUserRequest { string user_id = 1; }
//
// message UserResponse {
//   string user_id    = 1;
//   string username   = 2;
//   string email      = 3;
//   int64  created_at = 4;   // Unix timestamp
// }

/* Minimal HTTP/1.1 response builder in C */
#include <stdio.h>
#include <string.h>
#include <unistd.h>

void send_json(int fd, int status, const char *body) {
    char header[512];
    int  body_len = (int)strlen(body);
    snprintf(header, sizeof(header),
        "HTTP/1.1 %d OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %d\r\n"
        "Connection: close\r\n"
        "\r\n",
        status, body_len);
    write(fd, header, strlen(header));
    write(fd, body,   body_len);
}

/* PostgreSQL via libpq — parameterized query (prevents SQL injection) */
#include <libpq-fe.h>
#include <stdio.h>

void fetch_user(PGconn *conn, const char *user_id) {
    const char *params[1] = { user_id };
    PGresult *res = PQexecParams(conn,
        "SELECT id, name, email FROM users WHERE id = $1",
        1,    /* nParams */
        NULL, /* paramTypes  (let server infer) */
        params, NULL, NULL,
        0     /* result format: text */
    );
    if (PQresultStatus(res) == PGRES_TUPLES_OK && PQntuples(res) > 0) {
        printf("id=%-6s  name=%-20s  email=%s\n",
            PQgetvalue(res, 0, 0),
            PQgetvalue(res, 0, 1),
            PQgetvalue(res, 0, 2));
    }
    PQclear(res);
}

/* Redis cache-aside via hiredis */
#include <hiredis/hiredis.h>
#include <string.h>

/* Returns cached JSON string or NULL (caller must free reply) */
redisReply *get_user_cached(redisContext *rc, PGconn *pg,
                             const char *user_id)
{
    char key[64];
    snprintf(key, sizeof(key), "user:%s", user_id);

    redisReply *r = redisCommand(rc, "GET %s", key);
    if (r && r->type == REDIS_REPLY_STRING)
        return r;   /* cache HIT */

    freeReplyObject(r);

    /* cache MISS — query DB, then SET with 5-min TTL */
    /* fetch_user(pg, user_id) -> serialize to JSON ->  */
    /* redisCommand(rc, "SET %s %s EX 300", key, json_val) */
    return NULL;
}

/* JWT HMAC-SHA256 signature verification (OpenSSL) */
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include <string.h>
#include <stdio.h>

/* Compare two byte arrays in constant time to prevent timing attacks */
static int const_time_cmp(const unsigned char *a,
                           const unsigned char *b, size_t len) {
    unsigned char diff = 0;
    for (size_t i = 0; i < len; i++)
        diff |= a[i] ^ b[i];
    return diff == 0;
}

/* Verify HS256: header_payload = "base64url(hdr).base64url(payload)" */
int jwt_verify_hs256(const char    *header_payload,
                     const unsigned char *expected_sig, size_t sig_len,
                     const unsigned char *secret,       size_t secret_len)
{
    unsigned char digest[EVP_MAX_MD_SIZE];
    unsigned int  digest_len = 0;

    HMAC(EVP_sha256(),
         secret,   (int)secret_len,
         (const unsigned char *)header_payload, strlen(header_payload),
         digest,  &digest_len);

    if (digest_len != sig_len) return 0;
    return const_time_cmp(digest, expected_sig, digest_len);
}

/* epoll edge-triggered event loop skeleton (Linux) */
#include <sys/epoll.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

#define MAX_EVENTS 128

static void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

void run_event_loop(int listen_fd) {
    int epfd = epoll_create1(EPOLL_CLOEXEC);

    struct epoll_event ev;
    ev.events  = EPOLLIN;
    ev.data.fd = listen_fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

    struct epoll_event events[MAX_EVENTS];

    while (1) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1 /* block forever */);

        for (int i = 0; i < n; i++) {
            if (events[i].data.fd == listen_fd) {
                /* New connection */
                int client = accept(listen_fd, NULL, NULL);
                set_nonblocking(client);

                ev.events  = EPOLLIN | EPOLLET;  /* edge-triggered */
                ev.data.fd = client;
                epoll_ctl(epfd, EPOLL_CTL_ADD, client, &ev);
            } else {
                /* Data available — handle_client(events[i].data.fd) */
                /* With ET: must read until EAGAIN */
            }
        }
    }
}

/* Kafka producer using librdkafka (C client) */
#include <librdkafka/rdkafka.h>
#include <string.h>
#include <stdio.h>

static void delivery_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg,
                         void *opaque) {
    (void)rk; (void)opaque;
    if (msg->err)
        fprintf(stderr, "Delivery failed: %s\n",
                rd_kafka_err2str(msg->err));
}

void produce_event(const char *brokers, const char *topic,
                   const char *key,    const char *value) {
    char errstr[512];

    rd_kafka_conf_t *conf = rd_kafka_conf_new();
    rd_kafka_conf_set(conf, "bootstrap.servers", brokers,
                      errstr, sizeof(errstr));
    rd_kafka_conf_set_dr_msg_cb(conf, delivery_cb);

    rd_kafka_t *rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf,
                                  errstr, sizeof(errstr));
    rd_kafka_topic_t *rkt = rd_kafka_topic_new(rk, topic, NULL);

retry:
    if (rd_kafka_produce(rkt,
            RD_KAFKA_PARTITION_UA,    /* auto-select partition by key hash */
            RD_KAFKA_MSG_F_COPY,      /* copy payload into rdkafka */
            (void *)value, strlen(value),
            key, strlen(key),
            NULL) == -1) {
        if (rd_kafka_last_error() == RD_KAFKA_RESP_ERR__QUEUE_FULL) {
            rd_kafka_poll(rk, 100);   /* drain delivery queue */
            goto retry;
        }
    }

    rd_kafka_flush(rk, 10000);        /* wait up to 10s for delivery */
    rd_kafka_topic_destroy(rkt);
    rd_kafka_destroy(rk);
}

# -- Stage 1: Build (fat image with full toolchain) --
FROM gcc:13 AS builder
WORKDIR /src

# Copy source and build system first (layer caching)
COPY Makefile ./
COPY src/     ./src/

# Build release binary (strip debug symbols)
RUN make release CFLAGS="-O2 -DNDEBUG" && strip bin/server

# -- Stage 2: Minimal runtime --
FROM debian:bookworm-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends libpq5 ca-certificates \
 && rm -rf /var/lib/apt/lists/*

# Non-root user for security
RUN useradd -r -u 1001 -s /sbin/nologin appuser
WORKDIR /app
COPY --from=builder /src/bin/server .
USER appuser

EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/health || exit 1

ENTRYPOINT ["./server"]

/* Graceful shutdown via SIGTERM — C implementation */
#include <signal.h>
#include <stdatomic.h>
#include <stdio.h>
#include <unistd.h>

static atomic_int  in_flight        = 0;
static atomic_bool shutdown_req     = false;

static void handle_sigterm(int sig) {
    (void)sig;
    atomic_store(&shutdown_req, true);
}

void register_signals(void) {
    struct sigaction sa = { .sa_handler = handle_sigterm };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT,  &sa, NULL);   /* also handle Ctrl-C */
}

/* Called at start of each request handler */
void request_begin(void) { atomic_fetch_add(&in_flight, 1); }

/* Called at end of each request handler */
void request_end(void)   { atomic_fetch_sub(&in_flight, 1); }

int main(void) {
    register_signals();
    /* ... start server, accept connections ... */

    /* Main loop — stop accepting when shutdown requested */
    while (!atomic_load(&shutdown_req)) {
        /* accept() new connections */
    }

    /* Drain: wait for all in-flight requests to complete */
    fprintf(stderr, "[shutdown] draining %d in-flight requests\n",
            atomic_load(&in_flight));
    while (atomic_load(&in_flight) > 0)
        usleep(5000);   /* poll every 5ms */

    /* Close DB pools, deregister from service discovery */
    fprintf(stderr, "[shutdown] clean exit\n");
    return 0;
}