Skip to content

Revsheet

Let me pull what was actually covered on those topics first.Good. Covered extensively. Now the full list, correctly mapped to the PDF resume.

Full Revision Topic List

1. PEPPOL Platform

Architecture

  • 3-service split — what each service owns, communication between them, failure isolation
  • Why multi-service over monolith for this domain

RabbitMQ delivery

  • Publisher confirms — what they guarantee, what they don't
  • Consumer ACK modes — auto vs manual, crash-after-process-before-ACK scenario
  • Retry topology — exchange, retry queue with TTL, DLQ after N attempts
  • Why not Azure Service Bus — specific answer, not just "portable"
  • Async delivery at 7K/day — how throughput is sustained without bottleneck

Reconciliation + 24hr ambiguity window

  • What the ambiguity window is protecting against — external network failure, not your failure
  • What the reconciliation job does step by step
  • What happens at hour 25 if vendor still hasn't responded — this was an open question, have an answer
  • What the 0.14% failure cases actually are

Idempotency + distributed locking

  • Idempotency token — generated where, stored where, checked where
  • Atomic conditional update — UPDATE WHERE status = 'available' returning rowcount 1
  • Why this works as a lock, what happens if holder crashes

Compliance validation

  • What layers exist, what each checks
  • Where exactly an invalid invoice dies in the pipeline

Infrastructure

  • Docker Swarm on Azure VMs — why Swarm over AKS, specific tradeoffs
  • VNet isolation — what it's isolating, which ports, NSG rules
  • Service Principal over Managed Identity — why, what the tradeoff is
  • Cloud-agnostic storage/secrets — what the abstraction looks like (IDocumentStore, AddAzureKeyVault)
  • GitHub Actions → GHCR → SSH → docker service update — full CI/CD flow

2. ERP Core / Context-First Model

Before state

  • What CalculateActualPrice actually looked like — sequential DB calls per product, Roslyn per calculation, column bloat
  • What the performance cost was and why

LTCP / context-first refactor

  • Load → Transform → Compute → Persist — what happens at each phase
  • Two batch queries regardless of batch size — what they load
  • In-memory context object — what it contains, who builds it, what it enables
  • Compute layer — no DB awareness, pure function, own DI boundary, extractable

NCalc

  • What Roslyn was doing wrong — compiler spin per calculation
  • What NCalc does — purpose-built expression parser, compiled formula cache
  • What causes the ~17ms recompile (cache miss on first call per expression)
  • Singleton caching — what it would do, why not done yet, what the thread-safety risk is

Numbers to know cold

  • Pricing: 5s → 100ms
  • Descriptions: 2s → 50ms
  • Orders: 4s → 50ms
  • Invoices: 3s → 50ms
  • EPOS offline file generation: 10 mins → 8s
  • EPOS cold start: 40s → 6s

Order processing + async side-effect offloading

  • What went on RabbitMQ vs Hangfire — why the split
  • What Hangfire gives you that raw queuing doesn't

3. E-POS

Offline-first architecture

  • What gets persisted to IndexedDB — full order or delta
  • Per-customer order buffers — what they preserve, why needed in multi-client context
  • Background sync queue — what triggers sync, failure handling, zero order loss guarantee
  • Contextual inline flows — what this means concretely

Ports and Adapters at the frontend

  • What the ports are — pricing, promotions, payments interfaces
  • What the adapters are — IndexedDB adapter vs API adapter
  • What sharing domain logic across data sources actually means in Angular

Cold start 40s → 6s

  • What the redundant sequential calls were
  • What consolidation into batch queries looked like
  • Two phases of the improvement

Offline file generation 10 mins → 8s

  • 4 DB round trips per product → 3 per batch of 500 — what those calls were
  • What context-first batch processing means here specifically

4. ERP Satellite / Azure Function

50K sync events/day

  • Integration architecture — who publishes, who consumes, what format
  • Failure handling across 15 clients — retry, DLQ, idempotency
  • What kinds of events — ERP state change → external platform sync

Azure Function Blob trigger

  • Blob trigger mechanics — what fires it, input binding shape
  • Consumption plan — why right here, why wrong for invoice pipeline
  • What moved off the request path — 3s → 300ms

5. Distributed Systems Theory (resume claims + interview depth)

CAP theorem

  • C = Consistency, A = Availability, P = Partition tolerance
  • P is non-negotiable — real choice is CP vs AP
  • CAP is a per-operation choice, not a per-system label
  • PEPPOL is CP — wrong invoice delivered is worse than delayed
  • Named examples: CP = ZooKeeper, HBase / AP = Cassandra (default ONE), DynamoDB default

PACELC

  • Extends CAP to cover the non-partition case (latency vs consistency tradeoff)
  • Why PACELC is more useful day-to-day than CAP

Consistency models (full spectrum)

  • Linearizable / strong — every read returns most recent write, reads from primary
  • Read-your-own-writes — causal subset, your LSN-based implementation
  • Causal consistency — operations that are causally related are seen in order
  • Eventual — async replicas, no guarantee on when convergence happens

Read-your-own-writes implementation

  • Why it's hard in stateless REST
  • Your LSN approach — write LSN stored in Redis keyed by user, checked at request start, pin to caught-up replica
  • pg_stat_replication routing
  • Known gap — silently partitioned alive replica serves stale data past Redis TTL, needs primary heartbeat

Replication mechanics

  • WAL streaming, LSN, async vs sync replication
  • Sync replication tradeoffs — zero data loss, write latency cost, primary stalls if replica down
  • PgBouncer vs Pgpool-II vs HAProxy — what each does and doesn't do

ACID

  • Atomicity — all or nothing, rollback on failure
  • Consistency — DB invariants enforced before and after transaction
  • Isolation — concurrent transactions don't see each other's intermediate state (isolation levels: read uncommitted → serializable)
  • Durability — committed data survives crash (WAL, fsync)
  • Where ACID breaks in distributed systems — two-phase commit, Saga as the alternative

Quorum

  • W + R > N for consistency
  • Cassandra consistency levels — ONE, QUORUM, ALL, LOCAL_QUORUM
  • AP vs CP tuning per query in Cassandra
  • Why default is ONE not QUORUM (Cassandra defaults to AP)

6. Architecture Patterns (skills section claims)

DDD

  • Aggregate root — only entry point for mutations, enforces invariants
  • Value object vs entity — identity distinction
  • Domain event — what triggers one, who handles it, how it crosses service boundaries

CQRS

  • Read path vs write path — what's different
  • EF Core for writes, Dapper for reads — why that split
  • Read model — separate table, view, or projection — which and when

Ports and Adapters / Hexagonal

  • Port — interface owned by the domain
  • Adapter — implementation wiring the port to infrastructure
  • Why this matters for testability and swappability

Eventual consistency

  • Where you accept it — replica reads, satellite sync
  • Where you don't — aggregate hydration on write path, compliance validation

Saga pattern

  • Why 2PC doesn't work across microservices
  • Choreography vs orchestration — tradeoffs
  • Compensating transactions — what they are, when they fail

Outbox pattern

  • Why it exists — dual write problem between DB commit and message publish
  • How it works — write to outbox table in same transaction, relay publishes from outbox
  • Exactly-once delivery guarantee

7. C# / .NET Internals

async/await

  • State machine under the hood — what the compiler generates
  • ConfigureAwait(false) — what it does, when it matters (library code, no SynchronizationContext needed)
  • Deadlock scenario — where it happens, why, how ConfigureAwait prevents it
  • CancellationToken — propagation through call chain, what happens if ignored

DI lifetimes

  • Singleton, Scoped, Transient
  • Captive dependency — Singleton capturing Scoped is a bug
  • How to diagnose — IServiceProviderIsService, scope validation on startup

LINQ / IEnumerable vs IQueryable

  • Deferred execution — query runs when iterated, not when defined
  • IQueryable — expression tree, EF Core translates to SQL
  • IEnumerable — in-memory, already materialised
  • .ToList() too early — loads everything then filters in memory
  • .ToList() too late — N+1 if you're iterating inside a loop with DB calls

EF Core

  • Change tracking — how it works, when it's expensive (large reads — use AsNoTracking)
  • Migrations — what they generate, what they don't (data migrations are manual)
  • Optimistic concurrency — [Timestamp] / xmin in PostgreSQL, DbUpdateConcurrencyException

OAuth2 / OpenID Connect

  • Authorization code flow — full step by step
  • JWT — header/payload/signature, what the signature proves, what it doesn't
  • Refresh tokens — why they exist, rotation pattern
  • You built the auth server — what flows it supports, how token issuance works

8. SQL / DB Design

Window functions

  • ROW_NUMBER, RANK, DENSE_RANK — tie behavior differences
  • LAG / LEAD — first row NULL handling
  • FIRST_VALUE / LAST_VALUE — LAST_VALUE needs explicit full frame
  • CTE chaining to filter on window function results

Sliding windows

  • ROWS BETWEEN N PRECEDING AND CURRENT ROW
  • ROWS vs RANGE distinction

Gaps and islands

  • ROW_NUMBER subtraction — when to use, when to filter first
  • LAG + running SUM — when to use, NULL on first row

Normalization

  • 1NF → 3NF — what problem each solves
  • Intentional denormalization — invoice snapshots, point-in-time legal records

Indexing

  • B-tree structure
  • Composite index column order — equality first (high cardinality), range next, ORDER BY last
  • Left-prefix rule
  • Low selectivity — index skipped by planner
  • Only one range filter per composite index

Recursive CTEs

  • Anchor + recursive structure
  • Use cases — org charts, category trees, bill of materials

9. HLD — System Design Problems (re-drive any cold)

URL Shortener

  • Base62 over Base64 — why (URL safety)
  • RETURNING id pattern for atomic insert + ID retrieval
  • Single unique constraint over separate alias table
  • 301 vs 302 — caching tradeoff
  • Redis cache-aside decorator
  • Distributed rate limiting needs Redis-backed shared state, not in-process

Twitter Home Feed

  • Fan-out on write — precompute feed on post, push to follower Redis sorted sets
  • Push/pull hybrid — celebrity threshold, why pure fan-out breaks at scale
  • Redis sorted set — score = timestamp, range query for pagination
  • Cursor pagination over offset — why offset breaks at scale
  • Read path vs write path latency tradeoff

Notification System

  • Three delivery mechanisms — websocket (live), push notification (mobile background), email/SMS (async)
  • Fan-out at scale — batching for large accounts
  • Tiered handling — small account fan-out on write, large account (subreddit-scale) pull on read
  • Delivery guarantees — at-least-once, idempotency on consumer side

Ecommerce Ordering / Saga

  • Saga orchestrator pattern — why 2PC doesn't work across services
  • Redis stock gate — Lua script for atomic multi-product reservation
  • Why Lua — atomicity without a distributed lock
  • Indian payment gateway redirect flow — your browser leaves your domain, comes back via redirect with token
  • Compensating transactions — what happens when payment fails after stock reserved

Rate Limiter

  • Token bucket — steady refill, allows bursts up to bucket size
  • Sliding window — log of request timestamps, count within window
  • Fixed window — simple but boundary spike problem
  • Leaky bucket — smooths output rate, no burst allowed
  • Multi-threaded safety — Redis atomic operations, Lua for check-and-decrement
  • Distributed rate limiting — must be Redis-backed, in-process state is per-instance only

Building blocks you should be able to place and justify in any design:

  • Load balancer — when, round robin vs consistent hashing
  • API Gateway — auth, rate limiting, routing, SSL termination
  • Cache — cache-aside vs write-through vs write-behind, eviction (LRU/LFU), invalidation
  • CDN — static assets, edge caching, when it applies
  • Message queue — async decoupling, spike absorption, fan-out
  • Database selection — relational vs document vs wide-column vs search vs graph — justify every non-relational choice
  • Consistent hashing — node addition/removal, virtual nodes, relevance to Redis cluster and sharding

Pending drills (not done yet):

  • WhatsApp / chat system
  • YouTube / video streaming
  • Uber / ride matching

These three are gaps. If L2 goes HLD, any of them could come up. Worth at least one pass on each before the interview.