10. R3/R4 stack fundamentals

Spoken answer

A local is a compiler definite-assignment question; a field is initialized as part of object/class initialization. I say that before coding so I do not import a C/C++ assumption into Java. Locals must be definitely assigned on every path before a read or Java fails compilation. Instance and static fields default to numeric zero, false, or null. Array elements receive component defaults even when the array reference is local. A conditional assignment must cover every branch before the local is used. Initialize Live Code accumulators explicitly so the invariant is visible. The rule prevents unsafe local reads; it is not a runtime zero-fill promise for method variables.

Spoken answer

I use static for class-wide state or helpers and keep mutable global state out of Live Code unless the invariant requires it. A static nested node is useful because it does not retain the outer solution. Static state belongs to the class/class-loader, not each object. A static method has no implicit this and needs an object for instance state. Static initializers and blocks run once at class initialization in textual order. A static nested class has no hidden Outer.this reference. A non-static inner class captures the enclosing instance. Static methods hide rather than override; dispatch uses the reference/class name.

Spoken answer

I describe table, index, equals, collision structure, and resize in that order. HashSet is the same machinery when I need only membership. HashMap is a power-of-two table of bins; spread high bits and mask with n−1. Hash and then equals locate a logical key; collisions are expected. Bins begin as lists and Java 8+ can treeify at threshold 8 when capacity permits. Default load factor 0.75 triggers growth, normally doubling capacity. Average get/put is O(1); a bad collision bin degrades before/without treeification. HashSet stores elements as HashMap keys with one dummy PRESENT value. Neither standard type is thread-safe.

Spoken answer

Hash collections assume a key’s equality identity is stable while stored. Breaking that contract is a correctness error, not only a performance concern. Equal objects must have equal hash codes; unequal objects may collide. Override equals(Object), not an overload such as equals(Student). Override equals and hashCode together and keep equality reflexive, symmetric, transitive, and consistent. Mutating a field used in hashCode after put makes lookup search a different bin. Prefer immutable key objects or stable IDs. Use @Override so signature mistakes fail at compile time.

Spoken answer

A heap is for repeated access to one extreme, not complete sorted traversal. I write a non-overflowing comparator and an explicit tie-break when output determinism matters. PriorityQueue is a binary min-heap: peek O(1), offer/poll O(log n). Keep a min-heap of size K for top K largest values. Reverse the comparator for max-heap behavior; iteration is still not sorted. Never compare arbitrary ints with a-b because overflow can invert order. Use Integer.compare, Long.compare, or Comparator.comparingInt. Comparators must be transitive; PriorityQueue is not stable for ties.

Spoken answer

These defaults remove accidental legacy synchronization and repeated allocations while keeping the algorithm visible. Use ArrayDeque instead of legacy Stack for LIFO and instead of LinkedList for ordinary FIFO. push/pop/peek express stack; offer/poll/peek express queue. ArrayDeque is amortized O(1) at both ends and disallows null. It is not thread-safe; use a blocking/concurrent queue for shared workers. String is immutable, so repeated loop concatenation may copy prefixes quadratically. StringBuilder gives a growable buffer and amortized linear construction; StringBuffer is synchronized legacy.

Spoken answer

I use interfaces at replaceable boundaries and abstract classes only when shared state or a template is real. Then I separate compile-time overload selection from runtime instance dispatch. Interface defines a composable capability; a class may implement several. Abstract class can hold constructors, protected state, and a skeletal implementation. Overload selection is compile-time from parameter/static types. Override dispatch is runtime from the object type; use @Override. Return type alone cannot overload; covariant return is valid on override. Static methods hide, fields hide, and private/final methods do not override.

Spoken answer

PECS is the concise rule: Producer Extends, Consumer Super. Invariance prevents inserting a Double into a list promised to contain only Integer. List<Integer> is not a subtype of List<Number>; generics are invariant. ? extends T is a producer: read T safely, generally do not add. ? super T is a consumer: add T safely, read only as Object. Use a type parameter when several positions must share one inferred type. Type erasure removes most parameters at runtime, preventing new T() and instanceof List<String>. Avoid raw types because they defer errors to ClassCastException.

Spoken answer

Framework choice follows control flow: graph for fan-out/retry/cycles; bounded chain for SQL generation. IQVIA Deep Research used stateful graph orchestration and ranked evidence across 200+ websites. IQVIA Hybrid RAG used Azure AI Search hybrid+semantic and GraphDB over 200+ page BRDs. Ylogx used LangChain-shaped NL→schema→SQL→execution, not a retrofitted LangGraph claim. GiftedBooks is smaller PDF RAG, sub-300 ms and 99.5%, without claimed LangSmith/Azure. All production agent work was Python; Java remains live-code only. Do not put LLMs on Ylogx KPI hot GETs, RLS, Argus boxes, or Horizon actuation.

Spoken answer

A browser scrape can retry while search results survive in state. State is a typed contract carrying query, docs, ranks, answer, and errors. Nodes return partial updates; reducers append results from parallel branches. Checkpointing persists state by run/thread ID after nodes. Retrieve→grade→retrieve is a cycle and needs a hard iteration cap. A human gate can pause before publishing and resume from checkpoint. Do not invent a Postgres checkpointer or shipped review UI not on the resume.

Spoken answer

Route clause IDs to lexical-heavy hybrid; relationship questions add graph hops. Hybrid combines lexical and vector retrieval. Lexical matching finds exact IDs such as REQ-1044. Vector similarity finds paraphrased meaning. Azure semantic ranker reranks candidates; it is not the embedding index itself. GraphDB follows explicit DEPENDS_ON relationships that cosine cannot express. The writer sees a bounded cited set, not a stuffed 200-page PDF.

Spoken answer

A fluent answer with no supporting retained span fails; a SQL query outside allowed views fails before execution. RAG reduces hallucination but wrong retrieval can still ground a wrong answer. Use gold questions with expected citation IDs/spans and cite-or-abstain. LangSmith traces node/tool/retrieval paths without logging credentials or full confidential BRDs. SQL RAG is evaluated by SQL shape/result constraints, not English fluency. Execute parameterized read-only SQL as the user DB role with timeout and row cap. Cache keys include tier; +65% productivity never means superuser access.

Spoken answer

DNS turns a hostname into an IP so a client can open a socket. The first lookups hit the stub: browser cache, then OS cache, then a recursive resolver (ISP, VPC, or public). On a cache miss the recursive server walks root, then TLD, then the zone’s authoritative nameservers, and the answer is usually an A or AAAA, sometimes via CNAME or an AWS Alias. Java InetAddress.getByName is only that stub call on the JVM and OS; it is not a recursive server you wrote. TTL is why a wrong nameserver or a stale record can look like an outage while ECS is healthy. If they still ask classful A/B/C from that 2020 round, recite the ranges, then say the internet is CIDR and name the private blocks. On this resume GoDaddy is the registrar and Route 53 is the hosted zone; those are different jobs. Records then point at CloudFront or the ALB in front of ECS. This GFG prompt is older CN, not a Job 10454435 live question.

Example: User types the Ylogx hostname. GoDaddy NS records delegate to Route 53. Route 53 Alias A answers CloudFront or the ALB. CloudFront fetches origin through the ALB to an ECS task. Whiteboard Java is still InetAddress.getByName("example.com").

If they probe: www versus apex (Alias versus CNAME limits on apex); Alias to ALB versus CloudFront; A versus AAAA; stale TTL after a cutover; registrar is not the DNS host.

Spoken answer

MAC is a link-layer address, typically 48 bits, unique on a broadcast domain; switches forward frames with it. ARP maps an IPv4 address to a MAC on the local LAN so the next hop can be addressed. IP is a network-layer address that is assigned and routed across networks; routers strip the Ethernet header and write a new next-hop MAC. NAT rewrites IP and ports; the MAC never leaves that hop. In one packet, Ethernet MACs change every hop while IP source and destination stay until NAT. Java NetworkInterface.getHardwareAddress is the local NIC, not the destination MAC, and there is no portable “get dest MAC” API that belongs here. I will not invent an ARP configuration story at Ylogx. The interview is the layering.

Example: An ECS task in a private subnet sends to the ALB. On the subnet the Ethernet destination is the gateway or target MAC from ARP. After the router that MAC is gone and a new one is used. Users on the internet never see the task MAC or private IP.

If they probe: DHCP hands out IP, gateway, and DNS, but the switch still needs MAC to deliver the frame; VPN and tunnels encapsulate L3 so inner MACs are not the path; spoofing exists, so uniqueness is not a security control.

Spoken answer

The spoken walk is DNS, then a TCP three-way handshake (or QUIC over UDP if the browser negotiated HTTP/3), then TLS, then HTTP GET, then HTML, then more GETs for assets, usually hitting a CDN before origin. TCP is a reliable ordered byte stream. UDP is datagrams with no handshake. Horizon’s GStreamer camera at 60 FPS is the honest UDP-family example on this resume, not a claim that amazon.com video is my stack. Do not recite seven OSI layers unless they ask; map DNS and HTTP to application, TLS beside presentation, TCP or UDP to transport, IP to network, Ethernet and MAC to data link. The same walk at Ylogx is CloudFront, then ALB, then ECS. The resume number is sub-210 ms from cache and edge, not an LLM on the dashboard hot path. This GFG CN prompt is not a Job 10454435 live question.

Example: Browser resolves, connects 443, completes TLS with a cert that matches the name, GET /, CloudFront cache hit for static, origin for HTML. Ylogx is the same sequence at internship scale.

If they probe: cookies on later requests; 301 www versus apex; TLS name mismatch; 502 (bad gateway between CloudFront or ALB and origin) versus 504 (origin timeout).

Spoken answer

Kafka was asked because that candidate’s stack had Kafka; this resume does not. Order is per partition, not topic-global. The same key hashes to the same partition, so that key is FIFO. More partitions buy consumer parallelism in a group, not a total order. Producer acks=all plus ISR is the durability versus latency knob. A consumer group is competing consumers on partitions. Replicated partitions and leader failover are the fault-tolerance story; a rebalance can pause a partition if offsets are mishandled. The Java mental model is ProducerRecord(topic, key, value); I did not run this in internships. Honest line: Postgres and Redis at Ylogx; if ordered events were required I would key by tenantId or dashboardId.

Example: If they insist on a sketch, new ProducerRecord<>("events", tenantId, json) so one tenant stays on one partition. I will not claim I operated Kafka at Ylogx.

If they probe: log compaction; exactly-once as idempotent producer plus transactions — name it, do not lecture; B+ Tree was the other igreaper CS item and belongs in the database chapter.

Spoken answer

REST here means resources in URLs, HTTP verbs, a stateless server, and usually JSON. Cache with GET and headers, and treat errors as status codes, not 200 {success:false}. Ylogx BI was REST on FastAPI and NestJS; GraphQL and ProtoBuf are skills, not that app’s on-wire protocol. GraphQL helps nested over-fetch, while ProtoBuf fits high-frequency binary such as Argus-style metadata, not Recharts KPI JSON. Java mapping is @GetMapping or HttpClient.send, returning ResponseEntity.status(HttpStatus.NOT_FOUND) when the resource is missing. Authorization on this resume is REST plus RLS and RBAC across 3 org tiers, so a 200 with empty rows is the wrong face for a forbidden tenant. This IE.in list is not UTA two-DSA and not a 10454435 prediction.

Example: GET /kpis/ops with a JWT, NestJS guard, Postgres RLS, 200 JSON for the caller’s tier or 403 if the org is wrong. Report create is POST, not a GraphQL mutation on this app.

If they probe: PUT and DELETE are idempotent, POST is not; pagination; CORS is a browser rule, not REST itself; 401 versus 403.

Spoken answer

The resume line is configured GoDaddy DNS with Route 53 to route traffic through an ALB. GoDaddy is the registrar. Route 53 is the authoritative hosted zone. Nameservers on GoDaddy must point at Route 53; split-brain records on both is a failure mode. Typical records are apex and www Alias A to CloudFront or ALB, with ALB health checks on ECS targets. Failure modes I will name are NS not delegated, TTL still on an old IP, and host-header mismatch on the ALB. DNS sits on the critical path of 99.9% uptime and sub-210 ms. The www versus non-www 403/noindex SEO debug is prep-only and not on the Aug 2026 resume, so I will not lead with it.

Example: Buyer visits the apex. Route 53 Alias answers CloudFront. CloudFront origin is the ALB. ALB forwards to a healthy ECS task. A leftover A record to an old IP with a long TTL looks like downtime with a healthy cluster.

If they probe: Alias versus CNAME on apex; health-check 502 when all targets drain; IPv6; do not tell the SEO isolation story unless they already heard it.

Spoken answer

CloudFront is the CDN: cache JS, CSS, and images at the edge; origin is ALB then ECS. Fewer hits to containers is Frugality before a larger instance class. After deploy, Cache-Control and invalidation matter. Dashboard JSON is user-specific and RLS-scoped, so I will not cache tenant JSON at the edge. CloudFront is the AWS edge I can defend. Nginx is on the skills list as reverse proxy, TLS, and static, not “Ylogx edge was Nginx.” sub-210 ms is the latency number. Redis −35% bot DB latency is application cache, not the CDN; do not mix them.

Example: First paint of Recharts JS from a nearby PoP. GET /kpis/ops bypasses or uses a short TTL and still hits NestJS so RLS runs. Redis may hold a hot schema answer after a successful RLS query.

If they probe: CloudFront 403 (WAF, geo, signed URL) versus ALB 502 versus origin 5xx; invalidation versus versioned asset names.

Spoken answer

Nginx is a reverse proxy, TLS terminator, static-file server, simple load balancer, and gzip hop. On projects the usual picture is proxy_pass to Node or FastAPI. ALB is managed L7 with host and path rules, target groups, and ACM certs. CloudFront is global cache and TLS at PoPs. A Java JAR would still sit behind Nginx or ALB; business logic does not live in the proxy. Honest line: I know Nginx as a proxy; the path I shipped at Ylogx is CloudFront → ALB → ECS. I will not invent a production Nginx TLS hop in AWS.

Example: Locally, location /api/ { proxy_pass http://nest; } and location /rag/ { proxy_pass http://fast; }. In AWS those path rules are ALB listener rules to ECS services.

If they probe: worker_connections; WebSocket Upgrade headers — only if they push, and I will not invent a WS Nginx config I did not ship.

Spoken answer

HTTP is the client asks, the server answers, and the connection may close. Polling is repeating GET: simple, cacheable, and it works through proxies. A WebSocket starts as HTTP Upgrade, 101 Switching Protocols, then bidirectional frames on one TCP (or QUIC). I will describe that trade-off and I will not claim a socket fan-out bus that is not on the resume. WebSockets win for Argus-style camera alerts or tiles that would DDoS Postgres if polled every second. HTTP wins for the report builder, SQL RAG, and anything request-scoped behind RLS. Java 11 HttpClient.newWebSocketBuilder is a thirty-second sketch; Live Code is still DSA. Metrics I may use are 30 dashboards, ops +60%, and sub-210 ms API. Two-hundred-ten milliseconds is request latency, not a WebSocket tick rate.

Example: An ops KPI tile polls GET /kpis/ops every few seconds through CloudFront and ALB. An Argus alert could be a push. I will not say Ylogx shipped Redis pub/sub fan-out for all 30 tiles.

If they probe: sticky sessions versus Redis pub/sub across ECS tasks; idle timeouts and heartbeats; wss:// plus JWT on handshake; a socket is not a backdoor around RLS.

Spoken answer

Live video treats a late frame as the wrong frame. UDP sends datagrams; the pipeline would rather drop than stall. TCP retransmission causes head-of-line blocking that freezes a 60 FPS GStreamer path. RTP sits on UDP; GStreamer is how Horizon moved camera frames. Loss becomes artifact, not freeze, if the pipeline is built for it. Java analogue is DatagramSocket and DatagramPacket — no accept, no connection — but Horizon code was ROS2, Python, and C++, not Java. Ylogx REST wants TCP and TLS so a report row is not dropped. Resume metrics are 60 FPS and ERC 17th / 80+. I will not quote FPS as an iperf SLA. GitHub Gstreamer-UDP supports the protocol story; it is not a separate product with extra metrics.

Example: Camera → GStreamer UDP/RTP across the rover network at 60 FPS. A dropped datagram is a glitch. The same resume’s Ylogx dashboard uses HTTPS so a KPI row is acked.

If they probe: why DNS still uses UDP 53 (and TCP when truncated); QUIC and HTTP/3 also use UDP but that is not Horizon; congestion control is on the application or RTP side.

Spoken answer

OSI is seven layers: Application, Presentation, Session, Transport, Network, Data Link, Physical — a teaching model. TCP/IP is four: Application (HTTP, DNS, TLS in practice), Transport (TCP or UDP), Internet (IP), Link (Ethernet or Wi-Fi). Interview mapping is REST and WebSockets at application, the TCP handshake at transport, IP at network, MAC and Ethernet at link. TLS sits on TCP, or inside QUIC. I will not spend time on session versus presentation unless they insist. Ylogx HTTPS is application plus TLS plus TCP plus IP. Horizon camera is application plus UDP plus IP.

Example: Browser GET to CloudFront uses all four TCP/IP layers. Horizon 60 FPS GStreamer skips TCP on the camera path.

If they probe: where TLS lives (not “layer 6” as a job); QUIC combining TLS and transport over UDP; do not invent seven-layer Ylogx diagrams.

Spoken answer

TCP is connection-oriented: three-way handshake, ordered byte stream, ACK and retransmit, congestion control. A socket is the four-tuple. UDP has no handshake, preserves message boundaries, and does not guarantee delivery or order; the header is small. UDP fits latency-sensitive media, DNS queries on port 53 (TCP if truncated), and QUIC/HTTP/3. Java is Socket and ServerSocket versus DatagramSocket. BufferedInputStream on TCP hides message boundaries; HTTP frames for you. TCP loss stalls all streams on that connection, which is HTTP/2’s head-of-line pain. UDP and QUIC can avoid that stall. Resume: REST and TLS are TCP; GStreamer live cam is UDP.

Example: new Socket(host, 443) for a Ylogx health check. DatagramPacket toward a GStreamer sink for a camera frame. I will not claim HTTP/3 on NestJS.

If they probe: head-of-line on HTTP/2 versus HTTP/3; checksums; UDP still has ports; “reliable UDP” is an application protocol on top, not magic.

Spoken answer

The client sends SYN with its initial sequence number, the server replies SYN-ACK with its ISN, and the client ACKs so both sides have sequence space and data can flow. Close is FIN and ACK each direction (four-way), and TIME_WAIT holds the four-tuple so stray packets die. RST aborts; half-open means one side is gone and keepalive or a read error surfaces it. TLS is after TCP, except QUIC, so saying “HTTPS handshake” without TCP is incomplete. Java new Socket(host, port) blocks until the OS has finished the handshake, and ServerSocket.accept completes the server side. SYN flood is half-open SYNs filling the backlog, which is not a Ylogx war story.

Example: Browser to CloudFront 443: SYN, SYN-ACK, ACK, then ClientHello. new Socket("example.com", 443) in Live Code is that client side.

If they probe: simultaneous open; TIME_WAIT size; SYN cookies; why HTTP/3 and QUIC avoid this TCP dance; not a Job 10454435 named question.

Spoken answer

HTTP 1.1 is text with persistent connections and a Host header; pipelining is rare, so you get one outstanding request per connection in practice, many connections, and head-of-line at the HTTP layer. HTTP 2 is binary frames, multiplexed streams on one TCP, and HPACK headers; server push is mostly unused, and packet loss still stalls that TCP connection. HTTP 3 is HTTP over QUIC/UDP with TLS 1.3 built in, 0-RTT resumption, no TCP head-of-line, and connection IDs that can survive NAT or IP change. Browser to CloudFront may negotiate 2 or 3, while origin to ECS is often HTTP 1.1 or 2. I will not claim we ran HTTP 3 on NestJS. Java 11 HttpClient speaks 1.1 and 2 via Version.HTTP_2, and stock JDK has no HTTP 3 one-liner. sub-210 ms is caching, edge, and pooling, not “because HTTP 3.”

Example: Chrome to CloudFront might be h2 or h3. ALB to NestJS on ECS is not a claim of HTTP/3. HttpClient.newBuilder().version(HttpClient.Version.HTTP_2) is the Java sketch.

If they probe: head-of-line difference between 2 and 3; HPACK versus QPACK; 0-RTT replay risk; do not credit latency to HTTP/3.

Spoken answer

TLS gives confidentiality, integrity, and server authentication via a certificate. After TCP the flight is ClientHello, ServerHello plus cert, key agreement, Finished. TLS 1.3 is one RTT, and 0-RTT on resume. The cert must match the hostname using SNI. CloudFront and ALB terminate TLS; origin can be HTTP inside the VPC or TLS to the ALB. Java is https:// on HttpClient, or SSLSocket; the trust store is cacerts unless you custom a TrustManager, which you should not do in an interview. TLS is not JWT. TLS is the pipe; JWT is who the user is. Ylogx is HTTPS plus JWT and RBAC plus RLS. TLS is not tenant isolation.

Example: Browser to CloudFront on 443 with a cert for the Ylogx name. ALB can present an ACM cert. NestJS still checks JWT and Postgres still applies 3-tier RLS.

If they probe: MITM on cleartext HTTP; HSTS; “is TLS enough for tenant isolation?” — no, RLS; client certs not claimed.

Spoken answer

Two-xx: 200 OK, 201 Created, 204 No Content. Three-xx: 301 or 302 for www versus apex, 304 Not Modified for CDN or browser cache. Four-xx: 400 bad input, 401 unauthenticated, 403 authenticated but forbidden under RLS or RBAC, 404, 409 conflict, 422 semantic, 429 rate limit. Five-xx: 500 bug, 502 bad gateway between ALB or CloudFront and origin, 503 overloaded, 504 origin timeout. Java is HttpStatus.FORBIDDEN versus UNAUTHORIZED. Returning 200 for a 403 to “hide” tenants is a leak and a lie. 403 is the HTTP face of a wrong org tier; 3-tier RLS is the real control. CloudFront 403 is not RLS 403; isolate the hop.

Example: Missing JWT → 401. Valid JWT, wrong org → 403 from the API; empty 200 is wrong. CloudFront 403 from a WAF rule is a different hop than Postgres RLS.

If they probe: 201 plus Location; 429 plus Retry-After (rate limiter live count is 1 in other loops, not UTA); 502 versus 504.

Spoken answer

HTTP is request and response, client-driven; intermediaries understand methods, status, and cache. A WebSocket starts as HTTP with Upgrade: websocket and Connection: Upgrade, then framed messages both ways with no per-message status codes. Proxies must forward Upgrade. ALB supports WebSockets; naive idle timeouts kill sockets, so you heartbeat. Security is wss:// and still auth — ticket, cookie, or JWT on handshake. The same RLS rules apply: a socket is not a backdoor around Postgres. Use HTTP for CRUD and reports. Use WebSockets for event streams. Mix as REST to subscribe and WS to listen. Skills list has WebSockets; I will not invent a fan-out bus for the 30 KPIs.

Example: GET /reports/42 stays HTTP. A camera alert channel would Upgrade to wss:// and send frames. Ylogx 30 dashboards I describe as live-ish REST, not a claimed socket.io mesh.

If they probe: 101; ping/pong; sticky load balancer versus Redis pub/sub; SSE as server-to-client still-HTTP.

Spoken answer

ARP maps IPv4 to MAC on the local net. It does not cross routers, which is why MAC changes per hop. A port is transport demultiplexing: 443 HTTPS, 80 HTTP, 53 DNS. WebSocket often shares 443 via Upgrade. NAT maps many private IPs to one public IP and breaks unsolicited inbound without port-forward or an ALB. ECS tasks are private. The ALB is the public VIP. Users never speak ECS task IPs. The path is Route 53 to CloudFront or ALB.

Example: Task 10.x talks to Postgres in the VPC using private IPs and local ARP. A laptop on the internet hits CloudFront, not 10.x.

If they probe: IPv6 and NDP instead of ARP; ephemeral ports; NAT timeout killing idle WebSockets; security groups versus NACLs at high level only.

Spoken answer

I would name four types out loud and stop until they ask for more. The Controller is HTTP-thin: it binds the body and returns 200 or 401, and it never runs SQL. The Facade orchestrates: it runs validators, then calls authenticate, and it is not a god class that also hashes passwords. The Service authenticates: it loads the user through the Repository and compares a hashed password. The Repository only loads the user row. I would clarify username and password only, and whether success is a session cookie or a JWT, because this HM card does not require a token factory unless they ask. Validation of null and format lives in the façade; the credential check is not a validator if-else pile. SOLID here is S so the Controller stays HTTP, and OCP so a new check is a new Validator class. This is Java Live Code LLD for Bhavya’s HM, not the Ylogx NestJS internship. If they then ask how I would ship it, I pick a session cookie or a short JWT; Ylogx isolation is JWT and RBAC at NestJS plus Postgres RLS for three organizational tiers.

Example. POST /login hits LoginController, then LoginFacade.login, then AuthService.authenticate, then UserRepository.findByUsername, then a hash compare. Session versus JWT is a clarify after that succeeds.

If they probe: where the hashed compare lives; session cookie versus JWT after success; this is not Login Tracker, which is unverified mentor practice.

Spoken answer

The follow-up they asked is to remove the if-else ladder in the façade. I would introduce a Validator interface with one method, validate on LoginRequest, and each check throws or returns. The façade holds a List<Validator> and loops, then calls auth.authenticate. Non-empty, format, and maybe length are validators; a wrong password is not. Credential failure is the Service returning false or throwing AuthFailed after a Repository lookup. I would not put if (role == ADMIN) ladders in the façade, because that is RBAC on APIs and RLS on rows, which is the Ylogx story, not this login LLD. Open-closed is the point: a new check is a new class, not another else-if. If I am stuck I still say four class names plus validators as a list. Live Code is Java; Ylogx shipped TypeScript NestJS, so I do not pretend this Spring façade is the intern bot.

Example. NonEmptyValidator, then EmailFormatValidator, then LengthValidator in a list; the façade loops; then AuthService does the hash compare. Adding a “must not be a disposable domain” check is a fourth class, not a new else if.

If they probe: where credential failure lives; why an ADMIN role check is not a validator; OCP versus a switch on field names.

Spoken answer

They asked where I would and would not use GenAI. I would not use a model as authorization, as an RLS policy, as a money total without SQL, or as rover actuation or PPE boxes. At Ylogx the natural-language prompt is the interface, and the SQL that actually runs is executed as the user’s database role so row-level security still applies. The LLM must not hold a superuser connection string, because then a prompt injection is a warehouse dump. I would use GenAI where volume is high and the answer is cheaply verifiable, such as a SQL result set or a cited RAG chunk. IQVIA Hybrid RAG plus LangSmith is the “should” story: 200+ sites and 200+ page BRDs, with traces that must not leak credentials. Ylogx SQL RAG is on the resume as +65% analysis productivity behind RLS, not because the model decides who can see the row. If they push “the bot is smart enough,” I say the bot is useful because isolation exists. This prompt is IE-asked on LC 7850431 in an R3 with k-th largest; it is not a Job 10454435 named live question.

Example. An analyst asks “revenue by region.” FastAPI proposes parameterized SQL; NestJS sets the caller’s DB role from the JWT; Postgres RLS returns only that tier’s rows. The model never opens a superuser connection.

If they probe: why the model cannot be the RBAC layer; what happens if the RAG connection is table owner; LangSmith traces and secrets.

Spoken answer

These LP prompts are IE-asked wording; the story I tell is the Ylogx resume, not an invented fight. For Dive Deep I talk bot database latency and Redis −35% plus RLS, not SEO 403, which is prep-only. For an issue that was not my task I talk isolation and latency while building the chatbot and reports. For conflict with a teammate or manager I keep it technical: RLS in the database versus app-only checks; the resume has no named interpersonal fight and I will not invent one. For Ownership I pair three-tier RLS with 99.9% uptime, because wrong-tier data is also a critical issue. For a complex problem or POCs I contrast FastAPI, NestJS, Postgres, Redis, and RLS with “just LangChain.” Login Tracker as SDE I R2 is unverified mentor practice, not this topic. I do not invent Job 10454435 LP text.

Example. “Would you ship the SQL RAG without Postgres RLS?” No. A missed WHERE on a new report query leaks, and ALB plus ECS would scale the leak. The resume number I pair with that decision is 99.9% uptime and +65% analysis productivity behind isolation.

If they probe: names of the three tiers — stay with resume wording “3 organizational tiers as role” unless confirmed off-resume; SEO 403 is not the primary Dive Deep.

Spoken answer

RBAC is who may call which API, and at Ylogx that lives in NestJS from the JWT. RLS is which rows Postgres returns even if the SQL is a JOIN or was generated by the LLM. The resume says RLS and RBAC for three organizational tiers as role; I do not invent labels like org, team, and user unless that is confirmed off-resume. NestJS maps the caller to the matching database role, and Postgres enforces the rows. SQL RAG must execute as the user’s DB role so RLS applies; +65% productivity is analysts stopping the wait on engineers for every slice, not a superuser bot. We still needed Redis −35% on bot database latency so security was not “add a check and ignore load,” and 99.9% uptime held. App-only RBAC is the door; RLS is the warehouse. Both layers are required.

Example. The same SELECT on facts runs for two callers. The JWT maps one caller to tier role A and the other to tier role B. Postgres policies return only that tier’s rows, including when the query is a JOIN written by the SQL RAG.

If they probe: named tier labels; SET ROLE versus a GUC; why the LLM connection cannot be table owner or superuser.

Spoken answer

App-only RBAC fails because one missed WHERE org_id = ? on a new report query leaks, and hiding a button in the UI is not a control. SQL RAG, an ad-hoc JOIN, an admin debug session, and a replica path all skip NestJS middleware if they hit Postgres as a privileged user. If the LLM holds a service-role connection string, a prompt injection can dump the warehouse. Cached bot answers must key by tier; a shared Redis key would serve another organization’s SQL result, and the resume does not name a TTL so I will not invent one. I would not ship the bot without database RLS. Scaling with ALB and ECS without RLS scales leaks. Earn Trust and Backbone here are three organizational tiers as role, not a speech about a secret scanner I cannot source.

Example. A new KPI JOIN for the 30 dashboards passes the NestJS role check. Without RLS, that SQL returns another tier’s facts. With RLS and the user’s DB role, the JOIN still returns empty for rows outside the caller’s tier.

If they probe: Redis cache key must include tier; FORCE ROW LEVEL SECURITY; why a service-role connection string is the wrong RAG design.

Spoken answer

Row-level security lives on the table or view: you ENABLE ROW LEVEL SECURITY and attach policies with USING for reads and WITH CHECK for writes. Enforcement is inside the engine on every SELECT, UPDATE, and DELETE, including JOINs, and including functions that run as the table owner unless you FORCE ROW LEVEL SECURITY. Session context is SET ROLE to the tier role, or SET a GUC that the policy reads with current_setting, after NestJS has authenticated the JWT. The app still authenticates; the database still filters. Table owner and superuser can bypass, so the RAG connection must not be owner or superuser. I test with fixtures that a cross-tier SELECT returns zero rows. I will not describe bypass exploits. This is why SQL RAG must execute as the user’s DB role.

Example. ALTER TABLE facts ENABLE ROW LEVEL SECURITY; a policy USING (tier_id = current_setting('app.tier_id')::int); NestJS sets that GUC from the JWT, then runs parameterized SQL on a non-owner role.

If they probe: FORCE versus ENABLE; policies on views; why the table owner bypasses unless forced; how the three org tiers bind to DB roles without inventing names.

Spoken answer

The skills list has JWT; Ylogx NestJS is the API auth surface. The resume does not say we used sessions at Ylogx, and it does not say we used Auth0 on that intern path. My honest default is a short-lived access JWT at NestJS so ECS replicas stay stateless, with RBAC claims that select the database role, and RLS still in Postgres. A server session cookie is valid computer science if they want revoke-all-on-logout without a denylist. I would not over-build: Bhavya’s HM login can stay username and password plus session. I do not put secrets or raw PII in the JWT payload, only sub, exp, and a role or tier id. Tokens authorize the API; the LLM never holds the warehouse superuser string. GiftedBooks is a lighter JWT-or-session API for per-user PDFs at sub-300 ms and 99.5%, not three-tier warehouse RLS.

Example. Access JWT in Authorization: Bearer; NestJS verifies iss, aud, and exp; maps roles to SET ROLE; Postgres RLS filters facts. Logout is drop the token plus a short exp, or a denylist if they require instant kill.

If they probe: refresh tokens versus access TTL; denylist versus short expiry; Auth0 as a Ylogx vendor — that is a skills-list item, not an internship bullet.

Spoken answer

Auth0 is on the resume under Frameworks, and OAuth 2.0 is under Technologies. Internship bullets never name Auth0, so I will not claim an Auth0 tenant at Ylogx. I would describe Auth0 as an authorization server with hosted login; the app is an OAuth client; the isolation story is still RLS and RBAC for three organizational tiers. A typical SPA and API uses authorization code plus PKCE against Auth0; NestJS validates the JWT iss, aud, and exp, then maps role to a Postgres role. I will not invent tenant names, rules, or MFA screens I cannot describe. If they push the dashboard, hosted login plus JWT validation is the ceiling unless confirmed off-resume. PKCE exists because a public SPA has no client secret. Client-credentials is machine-to-machine and is not how Ylogx end-user reports should run.

Example. SPA redirects to Auth0 /authorize with code_challenge and S256; callback returns code; client POST /oauth/token with the verifier; NestJS accepts Bearer access and sets the DB role. Auth0 issued the token; Postgres still enforces RLS.

If they probe: implicit grant is legacy; whether Ylogx used Auth0 in production — skills only unless confirmed; where the client secret must not live.

Spoken answer

Secrets live in process environment on the ECS task, not in Git, not in the frontend, and not in LangSmith traces. The resume lists Web Securities and AWS ECS and Docker; I do not claim AWS Secrets Manager or KMS unless that is confirmed off-resume. The database URL, an Auth0 client secret for confidential clients only, and Azure keys for IQVIA stay on the server. A public SPA has no client secret, which is why PKCE exists. IQVIA BRDs are confidential across 200+ sites and 200+ page documents; I do not log full document text. Ylogx 99.9% is availability; Earn Trust is three-tier RLS, not a secret-scan anecdote I cannot source. I skip JWT theatre if they want Ylogx for auth depth. JWT payloads still must not carry connection strings or raw PII.

Example. The ECS task definition injects DATABASE_URL; FastAPI reads it from the process environment; the SPA only has the Auth0 client_id. LangSmith traces store a run id and a cited chunk, not the warehouse password.

If they probe: rotation without naming Secrets Manager unless confirmed; what belongs in a JWT claim; why a SPA cannot hold a client secret.

Spoken answer

Nginx is on the skills list. Ylogx deploy bullets name CloudFront, ECS, Docker, ALB, and Route 53, so TLS died at CloudFront or ALB, not a claimed Nginx hop on that intern path. The standard role of Nginx is to terminate TLS, speak HTTP/2, and reverse-proxy to the app, with certificates on the edge and containers on a private HTTP port. The honest sentence is: I list Nginx; the intern path I can defend is CloudFront to ALB to ECS; same idea, TLS dies at the edge, not in FastAPI. Sub-210 ms on the resume is CDN and cache, not TLS algorithm trivia. I will not say I configured Nginx for Ylogx unless confirmed off-resume. Private keys stay on the terminator, not in the Git repository.

Example. Browser HTTPS to CloudFront; origin to ALB; ALB to an ECS task on a private HTTP port. The Nginx listen 443 ssl sketch is how I explain the skills item, not a Ylogx topology claim.

If they probe: certs in Git; HTTP between ALB and the task; whether FastAPI terminated TLS — it should not on this path.

Spoken answer

Redis −35% is bot database latency for hot schema and repeat natural-language to SQL answers. The cached payload must be tier-correct, so the key includes organization or role. RLS still applies when SQL executes; the cache is not a second source of truth for another tenant’s rows. Parameterized SQL, a read-only role, a timeout, and a row cap belong on the execute path. SQL RAG must run as the user’s DB role, or a cache hit becomes a leak even when the original policy was correct. I will not walk through catalog fishing as an exploit. Dive Deep is −35% and three-tier isolation together, not SEO 403. Plus 65% productivity only holds if the bot cannot leak.

Example. Cache key shaped like tier:2|sql-hash. A tier-1 caller never reads a tier-2 value. A miss runs parameterized SQL after SET ROLE / GUC, then stores only that tier’s result.

If they probe: TTL is not on the resume so do not invent one; stampede on a hot KPI; why a shared “global SQL result” key is unsafe.

Spoken answer

A JWT has three base64url parts separated by dots: header, payload, and signature. The header names the algorithm, typically RS256, and the type JWT. The payload holds claims such as sub, iss, aud, iat, exp, and maybe roles. The signature is a MAC or public-key signature over header.payload. An access token is not encrypted by default; JWS is not JWE, so anyone holding the token can read claims, which is why there are no passwords and no connection strings in the payload. Verification checks aud, iss, exp, and the signature with the Auth0 or JWKS public key; I never accept alg: none, and I do not paste keys. Opaque tokens need a server lookup; JWTs are locally verifiable and harder to revoke instantly without a denylist or a short TTL. Auth0 here is the skills authorization server that would publish JWKS, not a claimed Ylogx tenant.

Example. Payload { "sub": "user-id", "iss": "https://YOUR_TENANT/", "aud": "api://ylogx", "exp": 1710000000, "roles": ["tier2"] } signed RS256. NestJS loads JWKS and rejects a wrong aud. That YOUR_TENANT string is an illustration, not a production URL I will invent for Ylogx.

If they probe: JWE versus JWS; clock skew on exp; what belongs in claims versus what Postgres RLS still must enforce.

Spoken answer

A server session stores an id-to-user mapping on the server, and the browser sends an HttpOnly Secure SameSite cookie. Revoke means delete the session; across ECS tasks you need sticky sessions or a shared store such as Redis. A JWT access token has no session row, so replicas scale without affinity; logout is drop the token plus a short exp, or a denylist. Cookies are auto-sent by the browser, so CSRF needs SameSite or a CSRF token; a Bearer header is not auto-sent by a random site. I pick from requirements: kill-session-now prefers a session or a short JWT plus denylist; NestJS on ECS without sticky sessions prefers JWT. Ylogx-shaped is JWT at the API plus RLS at the database. Bhavya’s Spring login can stay a session if they never asked for tokens. I still do not put secrets in a JWT payload, and I still execute SQL RAG as the user’s DB role.

Example. Session: Set-Cookie: sessionId=...; HttpOnly; Secure; SameSite=Lax and delete the row to revoke. JWT: Authorization: Bearer eyJ... with a short exp, NestJS verifies locally on any ECS task, Postgres still applies the three-tier RLS policy.

If they probe: refresh tokens in an HttpOnly cookie versus access in memory; CSRF versus Bearer; Redis session store versus a JWT denylist.

Spoken answer

The access token authorizes API calls and should live minutes. The refresh token obtains a new access token, lives longer, and is not sent to resource APIs. The ID token is OIDC identity for the client, with sub and email, and it is not a substitute for RLS. I would keep refresh off the SPA localStorage if I can, using an HttpOnly cookie on the token endpoint; that is defensive and I will not give a theft recipe. Rotation issues a new refresh on each use and invalidates the old one. A hospital rotating-refresh story is off-resume; the mechanism is standard CS. A stolen access token’s blast radius is its TTL, and RLS still limits rows if the token’s role is scoped. I do not invent Auth0 refresh settings for Ylogx. NestJS should reject a refresh token sent as Bearer on a reports API.

Example. Access expires in minutes and goes to NestJS as Authorization: Bearer. Refresh is used only at /oauth/token with grant_type=refresh_token. The ID token tells the SPA who logged in; Postgres still filters by the three organizational tiers as role.

If they probe: rotation reuse detection at a high level; why an ID token is not AuthZ; whether RLS still applies after a refresh — yes, because a new access token still maps to the same DB role.

Spoken answer

OAuth 2.0 authorization code plus PKCE is the must-know public-client flow. The client makes a high-entropy code_verifier and a code_challenge as BASE64URL of SHA-256 of the verifier. The user is redirected to the authorization server /authorize endpoint with client_id, redirect_uri, scope, state, code_challenge, and S256. The user logs in at Auth0; the app never sees the password. The callback returns code and state; the client checks state. The client POSTs to the token endpoint with code, verifier, client_id, and redirect_uri; the server proves the challenge matches. The response is an access token, optional refresh, and an OIDC id_token. Resource calls send Authorization: Bearer; NestJS validates the JWT and maps role; Postgres RLS filters. A confidential server app may add a client secret in addition to PKCE; an SPA cannot. Implicit grant with a token in the URL hash is legacy. Client-credentials is machine-to-machine and never for Ylogx end-user reports. Auth0 here is the skills authorization server, not a claimed Ylogx vendor bullet.

Example. SPA builds verifier and challenge → Auth0 /authorize → 302 with code and state → POST /oauth/token plus verifier → Bearer access to NestJS → SET ROLE or GUC → RLS returns only that tier’s rows.

If they probe: why not implicit; why a SPA has no client secret; state versus PKCE (CSRF on the redirect versus binding this client instance to this code); where refresh is stored.

Spoken answer

Authentication is who you are: Auth0 or a password. Authorization is what you may do: RBAC on APIs. RLS is which rows exist for this role after authorization said run this query. App RBAC without RLS is a locked door and an unlocked warehouse window through JOINs. I do not use an LLM as authorization. At Ylogx both NestJS RBAC and Postgres RLS covered three organizational tiers as role, and SQL RAG ran as the user’s DB role. Plus 65% is the productivity number; it is not a license for the model to see every row. Auth0, if they bring it up, is a skills-list authorization server for AuthN, not the row filter.

Example. Auth0 says this is user X. NestJS says X may GET /reports. Postgres returns only X’s tier rows, even when the SQL RAG wrote a JOIN. A 200 with another tenant’s facts would be an AuthZ failure, not a successful query.

If they probe: ID token versus access token; FORCE ROW LEVEL SECURITY; GenAI as AuthZ — that is a should-not from the IE-asked card.

Spoken answer

The client speaks TLS to the edge. The app in the VPC speaks HTTP. Certificates and private keys stay on the terminator, not in the Git repository. Nginx listen 443 ssl and proxy_pass to upstream is the skills sketch; an ALB HTTPS listener and CloudFront HTTPS do the same job. I list Nginx; the Ylogx path I can defend is CloudFront plus ALB. I will not say I configured Nginx for Ylogx unless confirmed off-resume. Sub-210 ms is CDN and cache on that path. Secrets for TLS are the cert and key on the edge, which is the same Earn Trust idea as not putting the database URL in the SPA.

Example. Browser to CloudFront over HTTPS; CloudFront to ALB; ALB to an ECS task over HTTP on a private port. The FastAPI or NestJS process never loads a PEM from the repo.

If they probe: cert files baked into the image; HTTP/2 at the edge; Nginx versus ALB for this intern — CloudFront and ALB are the bullets.

Spoken answer

Secure means the cookie is sent only on HTTPS. HttpOnly means JavaScript cannot read it. SameSite=Lax or Strict reduces CSRF by limiting cross-site sends. These flags complement PKCE state on the OAuth redirect. I will not give bypass steps. For a Bhavya-style session login this is the cookie I would set. For Ylogx-shaped JWT APIs the access token is usually a Bearer header, not this cookie, unless they put refresh in an HttpOnly cookie. GiftedBooks can be a session or JWT on a per-user PDF API at sub-300 ms and 99.5%; it is still not three-tier warehouse RLS.

Example. Set-Cookie: sid=...; Secure; HttpOnly; SameSite=Lax; Path=/ after a successful Spring login. A refresh cookie, if used, is also HttpOnly and is sent only to the token endpoint, not to /reports.

If they probe: SameSite=None; Secure for a cross-site case; CSRF token with cookies; why refresh should not live in localStorage if you can avoid it — defensive only, no theft recipe.

Spoken answer

A B-tree and a B+ tree are both multiway trees built for disk pages, so one I/O loads many keys instead of one BST comparison. Height is about log_B n, where B is keys per page; a BST can degrade to O(n) and would issue an I/O per key, which is why databases do not use it as the default index. In a classic B-tree, payloads can sit in internal nodes, so a point lookup might finish before the leaf. In a B+ tree every heap pointer lives in a leaf and internals hold separators only, which raises fanout and usually shortens the tree. Leaves are linked, so ORDER BY, BETWEEN, and “rows for this tenant since yesterday” become a descent plus a leaf walk rather than an inorder hop across random pages. Postgres still prints “B-tree” in EXPLAIN; interviewers still say B-tree; the range-scan story is B+. Hash indexes are equality-only, so they are the wrong default for time-ordered bot logs or camera events. I did not implement a B+ tree at internships; I would still choose that shape for query_log(org_id, created_at) and Argus event(camera_id, ts) because those queries are ranges, not hash probes. Kafka in the same slot is unrelated CS: order is per partition, not a global warehouse log, and I did not operate Kafka at Ylogx.

Example: CREATE INDEX query_log_org_time ON query_log (org_id, created_at DESC) is a B+ leaf scan: find the first leaf for that org_id, then walk newer rows to explain the −35% bot-latency slice. A Hash index could not serve “last hour for org X.” Argus (camera_id, ts) is the same pattern for 20+ cameras without storing JPEGs in the index.

If they probe: “Why not BST?” height O(n) and one I/O per key. “B vs B+ for a PK lookup?” B can stop internally; B+ always goes to the leaf, but internals pack more keys so height often matches, and range plus the leaf linked list is the reason to lead with B+. “Did you code B+?” No.

Spoken answer

A transaction is a bundle of reads and writes that must look atomic to everyone else: all of it commits, or none of it does, and the result still satisfies FKs, CHECKs, and RLS. ACID is the interview word; the resume fact is that Ylogx dashboards and Argus events live in Postgres, not in Redis. Atomicity is the WAL plus rollback; consistency here means constraints still hold after commit; isolation is why two report builders must not each think they won the same dashboard.spec; durability is fsync of WAL, which is not the same number as 99.9% service uptime. A database deadlock is a cycle in the row-lock wait-for graph: session one updates dashboard 1 then waits on 2, session two does the reverse, Postgres aborts one with 40P01, and the app retries with ids sorted. Keep transactions short and never hold a row lock while the SQL-RAG bot calls an LLM. OS deadlock is Coffman’s four conditions on mutexes; Banker’s algorithm is avoidance, not something I shipped. Isolation levels are a different question from tenant isolation: RLS is which org’s rows you may see, not whether you can see a dirty write.

Example: Argus inserts an event and an alert in one BEGIN … COMMIT so a crash cannot leave a PPE detection with no alert row. Ylogx SQL RAG shares the warehouse with the report builder under a non-superuser DSN so a half-written dashboard cannot leak across the 3 organizational tiers.

If they probe: “SELECT FOR UPDATE?” serialize alert ack so two operators do not close the same violation. “Lost update?” two builders overwrite spec — a version column or UPDATE … WHERE version =. “Deadlock vs livelock?” cap retries. “SERIALIZABLE everywhere?” not claimed; Postgres default is read committed.

Spoken answer

This slot on that IE was a thin cloud vocabulary list, not a warehouse design interview, so I answer in one breath and sit down. S3 holds objects: PDFs, model weights, camera frames if anyone asked for pixels, not RLS-protected KPI rows. NoSQL in this resume means “I do not need SQL joins for this key,” which is Redis for hot bot answers, not a Mongo system of record for 30 dashboards. Sharding is how you split a primary when one machine cannot hold the tenants; I did not shard Ylogx, and inventing a shard key would be a lie. What shipped is one Postgres with RLS plus Redis as a cache in front of the bot path. REST, Docker, and ECS are how the app ran; CloudFront is the edge; I did not run EC2 by hand and I will not upgrade Kubernetes from the skills list into production ownership. Facts stay in Postgres so joins, transactions, and row policies still work. Redis cut bot database latency by 35 percent because it is a cache, not because it became the warehouse.

Example: a Ylogx dashboard spec jsonb row lives in Postgres under org_id so SQL RAG can join it to query_log under the same RLS GUC. The PDF bytes of an IQVIA 200+ page BRD would be an object, not a Postgres cell. Redis key (org_id, tier, qhash) may hold a hot NL answer; deleting Redis must not delete the dashboard.

If they probe: “When would you shard?” when one primary cannot take tenant growth — I did not. “Mongo for events?” Argus compliance joins stay in Postgres. “Is Redis NoSQL?” yes as a data structure server; still not the source of truth.

Spoken answer

Ylogx is a multi-tenant BI warehouse, so the spoken ER is org, role, user, dashboard, and query_log, not a dump of production tables. An org has many roles, users, dashboards, and log rows; each user has one role in this simpler sketch because the resume does not name a bridge table. Primary keys are stable UUIDs; every fact table carries org_id as a foreign key so joins stay tenant-scoped and so RLS has a column to predicate on. Role holds tier in {1,2,3} rather than inventing shipped titles, which keeps the “3 organizational tiers as role” bullet in third normal form instead of copying a tier name onto every dashboard. Dashboards store a jsonb spec owned by a user; query_log stores a SQL hash and a millisecond duration, which is how −35% bot database latency was measured, not a Redis-internal counter. NestJS RBAC decides which route a JWT may hit; Postgres RLS decides which rows even a generated SELECT may see, including when the LLM forgets WHERE org_id. Redis is a cache of schema and hot answers keyed by org, tier, and query hash; it is not a fourth entity and not the source of truth. Ninety-nine point nine percent uptime is ECS, ALB, and CloudFront, not WAL. I did not shard; one primary plus RLS is what I can defend. Sub-210 ms is the API path with the LLM off the KPI GET.

Example: after JWT mapping, the request does SET app.org_id and SET ROLE before SQL RAG. Policy USING (org_id = current_setting('app.org_id')::uuid) on dashboard and query_log means a join SELECT d.spec, avg(q.ms) FROM dashboard d JOIN query_log q USING (org_id) cannot leak another tenant even if the model omits the filter. Redis GET for that answer runs only after that query succeeds, and the cache key includes org and tier so a tier-1 hit cannot serve tier-3 rows.

If they probe: “Why hash SQL?” audit without retaining a prompt of business numbers. “Why Redis if RLS?” populate cache after a successful RLS query. “Sharding?” did not. “Many-to-many user-role?” resume does not specify; one role per user is the board sketch.

Spoken answer

Argus is a PPE and attendance detector on more than twenty camera feeds, so the ER is camera, event, and alert, not a video warehouse. Each camera has a stable id, a label that is not an IP, and a target of 24 FPS on the resume. An event is one detection or heartbeat, with kind in ppe, attendance, or heartbeat, optional class and confidence, and a bounding box of integers rather than a JPEG. Twenty cameras at 24 FPS is about 480 frames per second; inserting a row per frame would drown Postgres, so we log events, not pixels. An alert is zero-or-one per event that crossed a threshold, with status open, acked, or closed, and a unique event_id so the same detection cannot open two tickets. The insert of event plus alert is one transaction so a crash cannot leave a detection without an alert. The B+ index is (camera_id, ts) for “what happened on CAM-07 just now,” plus a partial index on open alerts. Postgres is the compliance log that supports joins; object storage is where frames would go if they ask. I will not invent README routes that 404, and I will not put worker names or RTSP passwords on the board. YOLOv9 moved from 73 percent to 89 percent mAP on 15,000+ images; those numbers are model quality, not a table name.

Example: BEGIN; INSERT INTO event (camera_id, ts, kind, cls, conf) VALUES ($cam, now(), 'ppe', 'no_helmet', 0.91) RETURNING event_id; INSERT INTO alert (event_id, status) VALUES ($id, 'open'); COMMIT; Then SELECT a.status, e.ts, e.cls FROM alert a JOIN event e ON e.event_id = a.event_id JOIN camera c ON c.camera_id = e.camera_id WHERE c.label = 'CAM-07' AND a.status = 'open' is the floor-staff join. Retry on 40P01.

If they probe: “Partition by day?” possible; not on resume. “Mongo for events?” structured compliance joins stay in Postgres. “Double insert at 24 FPS?” unique (camera_id, ts, kind) for heartbeats, not a unique on every bbox. “RLS like Ylogx?” skip unless they ask; this was logging, not a public multi-tenant stream.

Spoken answer

Prisma is a TypeScript schema that emits migrations and a typed client, which fits NestJS CRUD, and it is on the skills list. Ylogx bullets name PostgreSQL, not Prisma, so I will not claim Prisma shipped the intern warehouse. Even if a sketch uses Prisma models for org, role, user, dashboard, and query_log, findMany({ where: { orgId } }) is still an application filter: miss one query and you leak a tenant. Prisma does not emit row-level security policies; those stay as SQL. SQL RAG must run parameterized SQL as the request’s database role after SET LOCAL app.org_id, not as a superuser datasource. Live Code is Java, so Hibernate is the same idea if they ask, and neither ORM will appear in a DSA editor. Use include for the 30 KPI dashboards instead of looping findUnique, which is the N+1 trap. Raw SQL remains for timeout, catalog deny, and the RLS GUC. The sketch models are language-agnostic study ER, not a claim that schema.prisma was committed at Ylogx.

Example: a Prisma Dashboard model with @@index([orgId]) is fine for NestJS CRUD. The bot path still does $executeRaw`SET LOCAL app.org_id = ${orgId}` then a parameterized SELECT. If one admin report uses prisma.dashboard.findMany() with no where, RLS in Postgres is what still hides other orgs — the ORM will not save you if the DSN bypasses RLS.

If they probe: “Prisma vs Hibernate?” same typed-client idea; Live Code will not need either. “Does Prisma generate RLS?” No. “Did Ylogx use Prisma?” bullets say PostgreSQL; do not claim it.

Spoken answer

Pick the store from the access pattern, not from a blog ranking. Postgres is the system of record for Ylogx facts and Argus event/alert logs because I need joins, foreign keys, transactions, and row-level security; 99.9 percent uptime is the service path around that primary, not a reason to move KPI rows into Redis. Mongo is on the skills list and is the wrong warehouse for SQL RAG, tenant joins, and RLS. Redis cut bot database latency by 35 percent as cache-aside: GET the key, on miss load Postgres as the RLS role, then SET; on write, update Postgres first and delete the key. A Redis key without org and tier would scale a leak at the same 35 percent. FAISS is a vector index for GiftedBooks-style PDF RAG; IQVIA’s primary retrieval is Azure hybrid search, and neither FAISS nor a vector neighbor is an authorization or money total. GraphDB on the IQVIA bullet holds BRD relationships; Neo4j is skills, and I will not stamp it on Ylogx’s three-tier org tree or the 30 KPI dashboards. MySQL, Firebase, and Supabase are skills only; Firebase is not an RLS warehouse, and Supabase’s hosted-Postgres-plus-RLS idea is not what shipped — self-managed Postgres on ECS is. GiftedBooks sub-300 ms is embed-once top-k, not stuffing a PDF, and the README currently describing AegisAI is not this product. I did not shard. Cache-aside is the CS name; I will not invent a TTL, stampede lock, or Redis Cluster that is not on the resume. Frugality is Redis plus CloudFront before a larger RDS.

Example: bot asks “what was last week’s fill rate for my org?” Cache key orgA:tier2:sha256(sql). Miss → SET app.org_id → SELECT avg(ms) FROM query_log WHERE created_at > now() - interval '7 days' under RLS → SET Redis. A Mongo document per dashboard could not join that average to RBAC tiers. CAP in one sentence: Postgres primary leans CP for the tenant row; the Redis copy can be stale; source of truth stays Postgres.

If they probe: “Postgres vs MySQL?” RLS is why I lead Postgres for Ylogx. “FAISS vs pgvector?” skills say FAISS; IQVIA says Azure; I will not invent pgvector in prod. “CAP?” Postgres row is CP; Redis/CloudFront are AP-ish for hot reads. Don’t lecture Dynamo unless they name it.

Spoken answer

An entity is a thing we store as a table: org, camera, document. A relationship is a verb: a user owns a dashboard, a camera emits an event, a document contains chunks. An attribute is a column. Cardinality decides where the foreign key goes: one-to-many puts the FK on the many side; many-to-many needs a bridge table with a composite primary key, which is what span_chunk is. One-to-one is rare; Argus alert-to-event is the honest 1:1 via unique event_id. A weak entity cannot be identified without its owner: an event without camera_id is meaningless. A primary key is unique, not null, and stable, so we use a surrogate uuid or serial and never email, which changes and is PII. A foreign key references a primary or unique key so the join cannot dangle. Restrict deleting an org that still has users; cascade delete chunks when their document goes. A unique pair like (org_id, slug) is per-tenant uniqueness, not a global slug. Putting org_id on every Ylogx fact table is both the FK for joins and the RLS predicate, which is why we do not denormalize it away.

Example: query_log.user_id REFERENCES app_user(user_id) and query_log.org_id REFERENCES org(org_id) let SELECT u.user_id, avg(q.ms) FROM app_user u JOIN query_log q ON q.user_id = u.user_id AND q.org_id = u.org_id GROUP BY u.user_id stay inside one tenant. IQVIA span_chunk(span_id, chunk_id) is the M:N bridge. Argus alert.event_id UNIQUE REFERENCES event is 1:1.

If they probe: “Why UUID?” unguessable org ids on a public JWT mapping. “Why serial?” smaller B+ leaves for high-ingest Argus events. Ylogx was one primary — either is fine on the board. “Identifying vs non-identifying?” event without camera is identifying.

Spoken answer

First normal form means atomic cells: one value per column, no comma-separated lists pretending to be a set. A dashboard that stores kpi_ids = 'a,b,c' fails 1NF and should become a dashboard_kpi bridge; a jsonb object of chart settings on the dashboard row is still one typed column, while a json list of users is the smell. Argus stores one event row per detection, not a string of twenty camera ids. Second normal form is 1NF plus no partial dependency on a composite key: if query_log were keyed by (user_id, created_at) and also stored org_name that depends only on the user, that name belongs on org or user, not on every log row. Third normal form forbids transitive dependencies: user.org_name when an org table already exists fails; the resume’s “three tiers as role” puts tier on role, not copied onto every dashboard. We still denormalize on purpose for speed: Redis holds a copy that bought −35 percent bot latency, query_log.ms is a snapshot of duration, and a KPI snapshot keeps 30 Recharts charts from running eight joins. The source of truth stays in 3NF. Never denormalize org_id away, because RLS predicates on it. BCNF is a one-sentence follow-up if they push: every determinant is a candidate key; I will not rewrite the intern schema on the board.

Example: bad 1NF: event.cameras_csv = 'CAM-01,CAM-07'. Good: twenty camera rows and events that each reference one camera_id. Bad 3NF: dashboard.tier_name = 'executive' copied from role. Good: role.tier SMALLINT CHECK (tier IN (1,2,3)) and join when the UI needs a label — labels are not invented on the resume. Redis key (org_id, tier, qhash) is a denormalized copy of a 3NF answer, not a fourth warehouse.

If they probe: “Is jsonb a 1NF violation?” a single typed document column is acceptable; a json array of other entities is the list smell. “Why keep org_id everywhere?” RLS and joins, not because 3NF forbids it. “BCNF vs 3NF?” BCNF is stricter on determinants; 3NF is the board default.

Spoken answer

An index is a B+ tree from key to tuple id, so the engine can find rows without a sequential scan. Composite indexes use a leftmost prefix: (org_id, created_at) serves org_id alone and the pair, not created_at alone. I would run EXPLAIN ANALYZE before adding a second index, because every extra tree slows writes. On Ylogx I would defend primary keys, foreign-key org_id, and query_log(org_id, created_at DESC) because that slice is how −35 percent bot latency was investigated; reports 40 percent faster is the report path, not a claim that we added twenty indexes. On Argus, (camera_id, ts) and a partial index on open alerts are enough; do not B-tree bounding-box json, and do not pay ingest cost of extra trees on more than twenty streams. On IQVIA, unique (doc_id, ordinal) and run_id on span are relational; the vector index lives in Azure Search or, at GiftedBooks scale, FAISS — not a Postgres B+ on a text column. Refuse an index on every json key, boolean-only indexes with no selectivity, and one row per Argus frame. Hash indexes are not the default for time ranges. A standalone index on tier is three values and will not be selective.

Example: EXPLAIN ANALYZE SELECT avg(ms) FROM query_log WHERE org_id = $1 AND created_at > now() - interval '1 day' should show an index range scan on query_log_org_time, not a seq scan of every tenant. Argus CREATE INDEX alert_open ON alert (event_id) WHERE status = 'open' keeps the floor-staff query small. Do not CREATE INDEX ON event ((bbox::jsonb)).

If they probe: “Index on tier?” three values — poor selectivity; second column after org_id or a GUC, not standalone. “GIN?” arrays and full-text, not the KPI path. “Covering INCLUDE?” only if a query is proven hot. “Why not index every FK?” write amplification at 24 FPS ingest.

Spoken answer

Transaction isolation answers whether concurrent sessions can see dirty, non-repeatable, or phantom rows. Read uncommitted allows dirty reads in the textbook; Postgres will still not return uncommitted data even at that name. Read committed, the Postgres default, never returns a dirty row but a second SELECT in the same transaction can see a committed change, and a new row can appear as a phantom. Repeatable read freezes a snapshot of committed data so non-repeatable reads go away; Postgres snapshot isolation already blocks many phantoms, and I will say textbook versus Postgres if they care. Serializable in Postgres is SSI and may throw 40001, which the app retries. Most Ylogx reads are fine at read committed; keep the transaction to SET RLS GUC, SELECT, and INSERT log on one connection. Tenant isolation is a different word: RLS plus RBAC for three organizational tiers, not an isolation level. WAL durability is not 99.9 percent uptime. Redis persistence is optional; losing Redis makes the bot slower by giving back the 35 percent, and it must not change which rows RLS returns. I did not claim SERIALIZABLE everywhere, which would contend on thirty dashboards.

Example: two builders load dashboard 12, both UPDATE spec, last write wins — that is a lost update under read committed, fixed with a version column. SQL RAG: one transaction, same role, SET LOCAL app.org_id, a row cap, and a timeout, so a concurrent report builder’s uncommitted INSERT is invisible. Redis miss after a crash reloads those committed rows; it must not serve a cached answer from another tier.

If they probe: “Serializable everywhere?” write contention on 30 dashboards; not claimed. “Read committed for SQL RAG?” yes for reads; one tx, same role, row cap, timeout. “Phantom vs non-repeatable?” non-repeatable is the same row changed; phantom is a new row matching the predicate. “Is RLS isolation?” no — tenant isolation, not a level.

Spoken answer

Argus is an industrial PPE and attendance system that runs on live cameras, not a notebook demo. I trained YOLOv9 on more than 15,000 images and moved held-out evaluation from 73 percent mAP to 89 percent mAP. Inference holds 24 FPS across more than 20 camera feeds, and those workers are containerized. Postgres stores event rows such as camera id, class, confidence, and timestamp, not video blobs. After alerts existed, the site saw safety violations drop 50 percent and compliance double, which are operational numbers, not mAP. I treat 73 percent mAP as a fail for alerting humans because missed helmets and junk boxes both hurt trust. The ship bar was 89 percent mAP plus 24 FPS, and I will not invent API routes for argus-stream-api-server because that README is 404. Live Code is Java; this detector is Python with OpenCV around the model, and I say that split out loud.

Example: A person on camera 7 without a helmet should become a Postgres event and an alert after NMS, not a JPEG dump and not an LLM caption.

If they probe: Ask for TensorRT, a named GPU, ByteTrack, or REST paths, I refuse to invent them. If they mix Horizon 60 FPS into this story, I separate GStreamer video infrastructure from the Argus detector.

Spoken answer

Haar cascades and HOG plus SVM are hand-crafted features with a sliding window or a cascade, and they are fine for frontal faces or upright pedestrians in constrained light. They are brittle on PPE because pose, occlusion, vest color, and helmet versus hair change the appearance. Color thresholds break the first time a vest is orange instead of yellow or the bay lighting changes. OpenCV still decodes and resizes frames; that is preprocessing, not the detector. YOLOv9 is a one-stage detector with learned features and multi-scale boxes in one forward pass, which is the path to 24 FPS on many streams. A two-stage Faster R-CNN-class model usually leans accuracy and loses latency when you multiply by 20 cameras. Naive OpenCV does not take industrial PPE from 73 percent to 89 percent mAP at 24 FPS. I do not claim I benchmarked Faster R-CNN on 20 cameras unless I can confirm that off-resume.

Example: A Haar face cascade on a side-on worker wearing a dark helmet against a dark beam will miss the head; YOLO trained on 15,000-plus PPE images is what made 89 percent mAP possible.

If they probe: Probe color histograms or a custom OpenCV cascade I shipped, I say that was the naive baseline, not the production detector.

Spoken answer

mAP is mean Average Precision over classes using IoU-thresholded boxes, not a selfie accuracy on the training notebook. At 73 percent mAP the detector missed too many violations and also proposed junk boxes, so it was not shippable for a safety alert. The quoted jump is held-out eval after iterating on more than 15,000 images, not train-set accuracy. The first story is data and an eval gate, not I swapped to a bigger backbone. Lighting, PPE color, and rare no-helmet frames are a dataset problem, not a one-line OpenCV threshold. I treated 73 percent as a fail, not as a blog starting metric, and I do not invent a manager quote. 89 percent mAP plus 24 FPS is what I will defend as the ship bar before scaling to more than 20 cameras. Site outcomes of minus 50 percent violations and 2 times compliance are a different family of numbers after humans received alerts.

Example: If the rare no-helmet class is missed, recall on that class is junk even if overall pixel accuracy looks high; that is why 73 percent mAP failed for alerting, the same way a missed helmet in a bay full of compliant workers hides inside a vanity accuracy number.

If they probe: Ask which backbone change caused the 16 points, I stay on data, labels, rare misses, and a frozen held-out set rather than inventing an architecture swap.

Spoken answer

I split images or video clips so the same camera-day does not leak into validation, because shuffling every Nth frame from one video is leakage. I stratify by class such as helmet, no-helmet, vest, and person, and by site or lighting when I can. I never tune NMS or confidence on the test set I will quote. The 73 to 89 percent mAP pair is held-out, and 15,000-plus is the resume size of the dataset. If train loss falls while validation mAP is flat, that is overfitting, so I collect more rare PPE misses instead of only training longer. mAP is the gate before scaling to more than 20 cameras. Augmentations belong on train only; validation should look like real cameras. I do not invent an exact split ratio that is not on the resume.

Example: If Monday’s cam-3 clip is in train and Tuesday’s frame from the same fixed camera and lighting is in val, the model memorizes that bay and the 89 percent quote lies.

If they probe: Probe k-fold or a named split library, I repeat the unit is clip or camera-day, and the quoted test set stays frozen.

Spoken answer

A detector that looks better on a laptop and dies at 20 streams is a fail, because the resume ships 24 FPS. The latency budget is end-to-end decode, infer, NMS, and I/O, not only forward milliseconds. Interview knobs I can name without extra resume claims are input size, model width, skip-frame, one worker per stream versus batch, and GPU versus CPU. I do not claim TensorRT, INT8, or a named GPU unless I confirm that off-resume. Video blobs do not go to Postgres; events with camera id, class, confidence, and timestamp do. More than 20 feeds are containerized and 24 FPS held. Horizon 60 FPS is a different project on GStreamer, not this number. If a queue grows I would rather drop a stale frame than pretend a delayed PPE alert is live.

Example: Twenty cameras at 24 FPS is 480 frames per second of detect work in aggregate; a fat model that does 8 FPS on one laptop cannot be copied 20 times and still be the Argus story.

If they probe: Probe skip-frame policy or a GPU SKU, I discuss the constraint and refuse to invent hardware I did not write on the resume.

Spoken answer

Safety alerts need an audit trail of who, when, which camera, and which class. Files do not query violations last week on camera 7. A dashboard-only design means engineers can see a chart while floor staff still need alerts. Postgres rows are the source of truth for events, not JPEGs. The site metrics of minus 50 percent violations and 2 times compliance sit on top of that log-plus-alert loop. Those operational numbers are not mAP. I will not invent table schemas beyond camera, class, confidence, timestamp, and box. Containerized workers write events; they do not archive every frame into the database.

Example: A disputed alert on Thursday at 14:03 on camera 7 is a SQL row you can replay; a folder of unmarked videos is not an audit trail.

If they probe: Probe a time-series database or S3 for clips, I say Postgres is what the resume logs, and object storage for blobs is off-resume unless I confirm.

Spoken answer

They are not the same number. mAP is detector quality on a labeled held-out set, and 89 percent mAP is that family. Minus 50 percent violations and 2 times compliance are operational outcomes after alerts existed. I do not claim mAP caused 2 times by itself; the loop is detect, alert humans, behavior change, logged in Postgres. If precision is too low, people get alert fatigue and ignore PPE alarms, which is why 73 percent was unshippable. I quote both families separately: 89 percent mAP, 24 FPS, 15,000-plus images, and more than 20 cameras, versus minus 50 percent and 2 times. A missed helmet at 73 percent mAP is a false negative on the class that matters for safety. I will not invent a causal study or a manager quote tying the two families into one percentage.

Example: If ten true no-helmet events happen and the 73 percent model misses most of them, the floor still has violations; after 89 percent mAP and real alerts, the site metric can move, but that second number is behavior plus process, not AP on a PR curve.

If they probe: Insist mAP equals minus 50 percent, I refuse the collapse and redraw the two boxes on the whiteboard.

Spoken answer

StratifyLabs is a CV SaaS with a 3D simulation lab in the browser so you can prototype without a full local GPU training loop on every tweak. Minus 30 percent is ML iteration time, not Argus FPS and not Horizon 60 FPS. The marketplace of 50-plus models and datasets is a catalog, not 50 GPUs per user. The GitHub README is default Next.js, so I do not invent features. Resume wins over the README. Gemini RAG bots on Stratify are the interaction layer over the simulated scene, not the Argus YOLOv9 detector. Optional leadership mapping is Invent and Simplify or Frugality versus a GPU farm. I will not mix Stratify’s minus 30 percent into Argus 24 FPS.

Example: Tweaking a sample model in the browser instead of waiting on a local training job is the minus 30 percent iteration story; it is not 24 FPS PPE detection.

If they probe: Open the Next.js README, I stay on resume bullets and refuse invented inference APIs.

Spoken answer

No as a resume claim. Horizon is ROS2, GStreamer at 60 FPS, ZED 2 at more than 2 million points per second, a costmap, 17th of 80-plus teams, obstacle plus 40 percent, and collision minus 55 percent. 60 FPS is the camera pipeline, and the supporting repo Gstreamer-UDP is a webcam analogue, not Argus YOLOv9. If they say your CV project, I split three stories: Argus is detector plus mAP, Horizon is video infrastructure plus mapping, and Stratify is browser iteration. I keep 60 FPS and 24 FPS in different sentences. I do not put an LLM on the costmap or actuation. I do not claim I ran YOLO at 60 FPS on the rover. Live Code is Java; rover nodes were ROS2 Python with native camera libraries.

Example: The operator feed is GStreamer at 60 FPS over a UDP-style path; Argus is a different camera system at 24 FPS with YOLOv9 boxes.

If they probe: Try to merge YOLO into Horizon, I repeat that 60 FPS is not a detector metric and the costmap is occupancy, not PPE classes.

Spoken answer

Bounding boxes, mAP, and FPS are the source of truth for Argus. An LLM is not a 24 FPS detector and it is not auditable the same way as IoU-matched boxes. I do not replace YOLO with an LLM on frames. A rebuild is the same YOLO plus Postgres, with an optional replay buffer for disputed alerts. Argus boxes stay computer vision; IQVIA and Ylogx are where LLMs belong, and even there they are grounded. A fluent caption that says helmet present while the box missed the head is worse than a 73 percent mAP fail you can measure. I will not invent a multimodal checkpoint on this resume. If they want GenAI, I point at IQVIA Hybrid RAG and LangSmith, not PPE.

Example: A missed helmet at 73 percent mAP is a counted false negative; an LLM saying looks compliant cannot be gated the same way at 24 FPS on more than 20 cameras.

If they probe: Keep pushing multimodal, I name the should-not list: PPE boxes, Ylogx RLS, and Horizon costmap.

Spoken answer

DSA in the editor is Java. Argus is Python with YOLOv9 and OpenCV plus Postgres, not a Java detector. The same ideas still transfer: batching, queues, a latency budget, and a schema for events. I think in HashMap, stream, and worker the same way; this detector runtime is Python. I will sketch a detect loop in Python if they ask, and I will not pretend javac compiles YOLO. Multi-camera ingest is workers into a detector into an alert service, which is the same shape as a thread pool plus a queue in Java. I do not invent a JNI binding I did not ship. Horizon 60 FPS is still a different project if they pivot to the rover.

Example: A Java ThreadPoolExecutor with a bounded queue is how I would explain 20-plus camera workers in this editor, even though production inference was Python.

If they probe: Ask me to write convolution in Java, I sketch the nested loops and return to the 24 FPS constraint rather than a paper.

Spoken answer

Classical computer vision uses human-designed features such as Haar, HOG, SIFT, or color histograms plus a cascade, SVM, or sliding window. A CNN learns filters: early layers respond to edges and texture, later layers to parts and objects, trained end-to-end on boxes and classes. Convolution reuses the same kernel as it slides, which is the translation-ish property, and pooling or stride changes scale with some loss. Domain shift still hurts when lighting or PPE changes; CNNs need data, while Haar fails sooner on appearance change. Argus needed learned features for PPE variety; Haar and HOG were the naive baseline. A CNN is not classification-only; detection adds a head that emits boxes. I will not claim Inception-this or ResNet-that as a resume bullet unless confirmed. The 73 to 89 percent mAP path is data plus a learned detector, not a better Haar cascade.

Example: The same 3 by 3 kernel that fires on a helmet rim in the top-left of a frame can fire on a helmet rim in the bottom-right because weights are shared; Haar templates do not get that for free across PPE poses.

If they probe: Want a formula, I go to the convolution sketch next; if they want production, I go to 24 FPS and NMS.

Spoken answer

A small kernel slides over the image, and each output cell is the dot product of the kernel with that patch plus a bias, then a ReLU. You stack those layers so the receptive field grows. Stride and padding control the spatial size of the feature map. 3 by 3 stacks are the usual spoken story; I do not recite FLOPs unless they ask. The backbone is a stack of these convolutions, often with residuals or aggregations, emitting feature maps at several resolutions. Detection is not classification only: a head on those maps predicts boxes and classes. YOLOv9 still sits on this idea even if the paper names GELAN. OpenCV letterbox and color convert happen before this graph; NMS happens after.

Example: On a 3 by 3 patch of a helmet edge, a learned kernel that looks like a dark-to-light vertical step produces a large activation; sliding that kernel across the frame builds an edge map without a hand-written Sobel you have to retune per site.

If they probe: Ask for backpropagation math I keep one sentence on gradients and return to boxes, mAP, and 24 FPS.

Spoken answer

Two-stage detectors in the R-CNN family first propose regions and then classify and regress each proposal, which leans accuracy and is slower. One-stage detectors in the YOLO family predict box and class in one pass from grid, anchor, or anchor-free heads, which leans latency. Argus is 24 FPS times 20 cameras, so one-stage is the default defense. I do not claim I benchmarked Faster R-CNN on 20 cameras unless that is confirmed. YOLO versus two-stage is a constraint talk, not a paper recitation. Postprocess is still confidence filter plus NMS either way. A heavier two-stage that looks better on one laptop is still a fail if it cannot hold 24 FPS. Resume detector is YOLOv9, not YOLOv8 and not ByteTrack.

Example: If each of 20 cameras needs a box every 42 milliseconds to hold 24 FPS, a two-stage second network per proposal blows the budget; one forward pass plus NMS is the story I shipped toward.

If they probe: Ask about RetinaNet or FCOS, I map them to one-stage conceptually and return to the 24 FPS constraint.

Spoken answer

The backbone is a CNN feature extractor; the YOLOv9 paper names GELAN for efficient layer aggregation, and in an interview I say a deep CNN that emits multi-scale maps. The neck fuses scales in an FPN or PAN style so small helmets and large persons both get a map. The head emits box and objectness or class at each location, typically at several pyramid levels. YOLOv9 PGI is training-time auxiliary branches to keep gradient information, and inference can drop them; I do not claim PGI runs at 24 FPS as extra cost if I do not know the export graph. Preprocess is letterbox, resize, and color convert in OpenCV. Postprocess is confidence filter plus NMS. The resume says YOLOv9, not YOLOv8. I do not describe ByteTrack or OSNet as Argus.

Example: A small helmet at the back of a bay lights up a higher-resolution map, a large person in the foreground lights up a coarser map, and the neck is why both can be boxed in one pass before NMS.

If they probe: Ask me to draw PGI, I mark it train-only and keep inference as backbone, neck, head, NMS.

Spoken answer

One object produces many overlapping candidate boxes from nearby cells and scales. Non-maximum suppression keeps the highest-confidence box and suppresses neighbors whose IoU is above a threshold. The interview default is greedy NMS per class; soft-NMS and class-aware variants exist if they push. Too aggressive NMS merges two nearby workers into one box; too loose NMS duplicates alerts. NMS is CPU postprocess after the network; it is not the backbone. Alerts are logged after NMS, not for every raw head cell. I tune NMS on validation, never on the frozen test set I quote for 73 to 89 percent mAP. I do not invent a learned NMS module as a resume claim.

Example: Two boxes on the same helmet with IoU 0.9 and confidences 0.92 and 0.71 become one event after NMS; without NMS, camera 7 would insert two Postgres rows and page the floor twice.

If they probe: Ask for the exact IoU threshold I used, I explain the trade-off and do not invent 0.45 versus 0.5 as a shipped constant unless I remember it honestly.

Spoken answer

IoU is intersection over union of a predicted box versus a ground-truth box, and we count a match if IoU is at least a threshold, often 0.5, while COCO averages several thresholds. Precision is of the predicted boxes how many were right. Recall is of the ground-truth objects how many you found. Average precision is the area under the precision-recall curve for one class, and mAP is the mean over PPE classes. For safety, a false negative missed no-helmet is worse than an extra box, but you still cannot ship 73 percent if recall on the rare class is junk. Quoted 89 percent mAP is this family of metric on a held-out set. Accuracy on frames that contain a helmet hides missed boxes. I will not pretend 89 percent means 89 percent of pixels were classified correctly.

Example: If a no-helmet ground truth has IoU 0.2 with the only prediction, that is a miss; at 73 percent mAP those misses were too common to alert humans, which is the missed-helmet-at-73-percent example I will say out loud.

If they probe: Want COCO mAP@0.5:0.95 versus VOC-style mAP@0.5, I name the difference and admit I will not invent which averaging the resume tool used.

Spoken answer

Haar-like rectangle features are computed with an integral image so a rectangle sum is constant time. AdaBoost picks weak features, and a cascade of stages lets most windows die early. That is fast on CPU for faces with a pretrained cascade. It is not a general PPE detector. Haar is the naive OpenCV demo, not 15,000-class PPE. Pose, helmet versus hair, and site lighting break it sooner than a CNN. I did not ship Haar as the Argus detector. If they want production numbers I go back to 89 percent mAP and 24 FPS.

Example: A frontal face cascade on a well-lit ID photo can fire; a side-on worker with a yellow helmet under sodium lights will not become 89 percent mAP.

If they probe: Ask me to write the integral-image recurrence, I sketch prefix sums and return to why YOLO replaced this baseline.

Spoken answer

Histogram of Oriented Gradients builds a descriptor over a window, which is the Dalal–Triggs pedestrian story, then a linear SVM scores that window. You search with a sliding window and an image pyramid. It is a rigid template, it is slow if you pyramid densely, and occlusion and viewpoint hurt. HOG is the other naive baseline next to Haar. Argus did not ship HOG. Learned CNN features plus a one-stage head are what moved PPE to 89 percent mAP. I will not claim a HOG ablation table that is not on the resume. OpenCV can compute HOG; that still is not 24 FPS multi-cam PPE.

Example: An upright pedestrian in a paper dataset matches HOG; a crouched worker with a vest half-occluded by a pallet does not, which is why we trained YOLO on 15,000-plus site images.

If they probe: Ask for the 9-bin orientation histogram, I can name it and then refuse to pretend that was the shipped Argus stack.

Spoken answer

Background windows vastly outnumber hardhats, and no-helmet may be rare if most people comply. A model that always predicts person with helmet gets high accuracy and useless mAP on the violation class. That is consistent with treating 73 percent mAP as a fail: the mean can look less embarrassing while violations are still missed. Standard levers I can name as CS, not extra resume claims, are class weights, focal-style loss, oversampling rare frames, and mining negatives from real misses. I do not only scrape perfect PPE photos. Eval must report per-class AP, not a vanity mean that hides the rare class. The hard-example loop is how mAP moves without a magical architecture swap. I will not claim I used focal loss unless I confirm that off-resume.

Example: If no-helmet is 2 percent of boxes and the loss is unweighted, the detector learns to ignore the class you actually want to alert on, which is a missed helmet at 73 percent mAP.

If they probe: Ask for the exact class histogram, I say I counted boxes before training and I will not invent percentages that are not on the resume.

Spoken answer

I must hit 24 FPS before chasing 95 mAP, and the resume already chose that trade. Order is smaller input or a lighter YOLO variant first, then skip frames if the camera is 30 FPS and I need 24 detect FPS, then confidence and NMS which are cheap, and a heavier backbone last. On many cameras I do not run 20 copies of the fattest weights. Per-stream workers or a batched GPU are the shapes; I will not invent a GPU model name. A heavier model on a laptop that dies at 20 streams is the Argus hardest-bug class. Measure end-to-end, not only forward time. Drop the stream if the queue grows and log the drop. Horizon 60 FPS remains a different pipeline if they change projects.

Example: If I upscale input from 640 to 1280 to pick up small helmets, mAP may rise while 20 cameras fall below 24 FPS; I would rather keep 89 percent at 24 FPS than a prettier notebook at 6 FPS.

If they probe: Ask which knob I turned first, I start with input size and data, not a named accelerator.

Spoken answer

A process has its own PID, virtual address space, page tables, heap, and file-descriptor table, and crash isolation is the point. A thread is a TID inside a process with a shared heap and its own stack, registers, and program counter. Java is one JVM process; new Thread and pool workers share the heap, which is why synchronized and volatile exist, and a native SIGSEGV still kills the JVM. Isolation I actually shipped is an ECS task or Docker container as a process or pid-namespace boundary, not a Java thread. Horizon ROS2 nodes are processes talking over DDS, not one giant thread. Ylogx 99.9 percent and GiftedBooks 99.5 percent are process and container uptime, not I tuned JVM threads. Argus more than 20 cameras is many workers, processes or a bounded pool, at 24 FPS; I do not invent a Java Thread per camera in production. This is IE.in 2025-grad and GFG sde-1-17, same Rate Limiter loop, not UTA two-DSA.

Example: If an inference worker segfaults inside a shared JVM, the API dies with it; putting the detector in another container process keeps Postgres logging alive, which is why process beats thread for blast-radius on Argus-style workers.

If they probe: Ask GIL, I say CPython GIL is not the Java answer; the JVM maps to native threads.

Spoken answer

All four Coffman conditions are required: mutual exclusion so the lock is not shareable, hold and wait so you hold A while waiting for B, no preemption so you cannot steal a held lock, and circular wait. The Java example is thread 1 synchronized on a then b versus thread 2 synchronized on b then a, and the same bug happens with ReentrantLock if acquire order flips. I break any one condition: global lock order by identityHashCode or resource id, tryLock with timeout so I do not hold-and-wait forever, fewer locks, or never nest if I can compose one lock. I detect with a thread dump, jstack, or jcmd Thread.print, looking for BLOCKED plus a cycle. The design answer is fix app code, not kill minus 9 the JVM. The database cousin is two transactions updating rows in opposite order; Postgres detects and aborts one, and the app retries or locks rows in a global order. Ylogx is Postgres. I do not claim a production deadlock write-up I do not have, and I did not ship Bankers. This pair of IEs is still not UTA two-DSA; Rate Limiter count stays 1.

Example: A transfer method that always locks the account with the smaller identityHashCode first cannot form a circular wait with another transfer on the same pair of accounts.

If they probe: Ask wait versus deadlock, I distinguish BLOCKED cycle from livelock RUNNABLE retries.

Spoken answer

The stack is per-thread frames with locals, arguments, and return address, and it grows and shrinks with calls; StackOverflowError is too-deep recursion, not GC failed. The heap holds objects and arrays, shared by all Java threads; OutOfMemoryError Java heap space means the live set exceeds dash Xmx. GC reclaims objects unreachable from roots such as stack references, statics, and JNI, and you do not call free; pause is stop-the-world depending on collector. I do not lecture Eden, Survivor, Old, or G1 versus Parallel unless asked; one line is most objects die young and modern JDK default is generational G1. Internships did not tune dash Xmx or dash Xms. Latency numbers are API, Ylogx sub-210 ms and GiftedBooks sub-300 ms, not GC pause SLOs. This was IE.in 2025-grad memory management, Rate Limiter loop, not UTA. I do not invent a GC log from internships.

Example: A recursive path-sum that does not stop at leaves blows the stack with StackOverflowError while the heap is fine; allocating a huge ArrayList of frames blows the heap with OutOfMemoryError while the stack is fine.

If they probe: Push generations, I give one G1 sentence and return to stack versus heap.

Spoken answer

Bankers is deadlock avoidance, not detection and not Coffman prevention. You allocate only if the resulting state is safe. Tables are Max of process by resource, Allocation, Need equals Max minus Allocation, and Available. Safe means there exists a sequence that can finish: some process with Need less than or equal Available, pretend it finishes, add its Allocation back, repeat. Unsafe is not yet deadlock; deadlock cannot occur from a safe state if max claims are honest. This is rare in app servers; thread pools and connection pools are bounded resources, not Bankers. GFG sde-1-17 last live asked it with threads versus processes, not UTA two-DSA. I did not implement Bankers at Ylogx, IQVIA, or Horizon; we cap the pool instead.

Example: If three threads each may need 2 connections and the pool has 3, Bankers would refuse an allocation that leaves a state where no thread can finish; in production I size the pool and timeout rather than run the safety algorithm on every request.

If they probe: Want me to run a numeric tableau, I will, and I still will not claim Ylogx ran Bankers.

Spoken answer

The CPU uses virtual addresses, and the MMU maps them to physical frames via page tables, with a TLB on the fast path. A miss that is present walks tables; not present is a page fault. Demand paging brings pages from swap or file until touched, and a typical page is 4 KiB, though huge pages exist and I will not volunteer them unless asked. Isolation means process A cannot read process B’s virtual address space, so a Horizon ROS2 node crash is not the whole rover image, unlike a bad native thread in one process. This is GFG 6-months December 2020, older, still in bible 5.F. Ylogx ECS task memory limit is the practical cap, not a page table I configured. ZED 2 at more than 2 million points per second is a working-set problem: keep the costmap window in RAM and do not page the cloud. I do not invent a thrashing incident.

Example: If the rover tries to keep the entire dense cloud plus a huge JVM heap on a small box, virtual addresses still look fine while the working set no longer fits RAM, which is the bridge into thrashing.

If they probe: Ask me to walk a multi-level page table, I sketch VPN to PPN and return to isolation and working set.

Spoken answer

Thrashing means more time paging than running because the working set of runnable processes is larger than RAM. The CPU looks busy on disk I/O and idle for useful work. The fix is fewer concurrent processes, more RAM, or better locality, not add threads. The Java trap is dash Xmx larger than host RAM, which is OS swap plus GC, a death spiral. A heap that is too small is a different failure: allocation failure or a full GC loop, which is not OS thrashing, and I say the difference. Argus more than 20 cameras at 24 FPS needs bounded in-flight frames, drop or skip, not unbounded queues that blow RSS. Ylogx Redis minus 35 percent is cache, not swap. Same older GFG December 2020 R2. I do not invent a production thrashing ticket.

Example: Twenty camera workers each queueing uncompressed frames will page the box to death and miss 24 FPS; a bounded queue that drops stale frames keeps the working set inside RAM.

If they probe: Conflate GC stop-the-world with thrashing, I separate JVM pause from OS swap.

Spoken answer

Resume: YOLOv9 73%→89% mAP , 15k images, 24 FPS , 20+ camera feeds, Postgres logs, containerized, violations −50% , compliance 2× . Do not invent “one Java `Thread` per camera in prod.” Honest design: bounded worker pool (or one process per N cameras) + queue with backpressure ; drop frames vs unbounded RAM. Isolation: a crashed inference worker should not take the logger/API with it → process (container) boundary beats a shared-heap thread for fault isolation. 24 FPS × 20 cameras is a capacity question (pool size, queue bound), same shape as `ThreadPoolExecutor` core/max/queue — Live Code can be Java even if the ship was Python. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Argus is YOLOv9 on more than 15,000 images, 73 percent to 89 percent mAP, 24 FPS, and more than 20 cameras, and I do not put an LLM on PPE boxes.

Example: Resume: YOLOv9 73%→89% mAP , 15k images, 24 FPS , 20+ camera feeds, Postgres logs, containerized, violations −50% , compliance 2× .

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Resume: ROS2 rover, ERC 2024 17th / 80+ , GStreamer 60 FPS , ZED 2 2M+ pts/s , costmap −55% collision, obstacle +40% . Public `Gstreamer-UDP` = supporting webcam-stream artifact, not a second project. ROS2 node ≈ process (own VAS, DDS IPC). Pipeline threads exist inside GStreamer / rclcpp executors — shared-heap, need not-block-the-callback. 60 FPS = budget ~16 ms/frame. A blocking lock on the capture thread is a livelock/latency bug, not “use Bankers.”. 17th/80+, 60 FPS, 2M+ pts/s, −55% / +40% — concurrency for deadlines , not JVM GC lore. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Horizon is ROS2 with a GStreamer 60 FPS feed, and I do not put an LLM on the costmap or actuation.

Example: Resume: ROS2 rover, ERC 2024 17th / 80+ , GStreamer 60 FPS , ZED 2 2M+ pts/s , costmap −55% collision, obstacle +40% .

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Resume: FastAPI + NestJS, Postgres, 99.9% uptime, sub- 210 ms , CloudFront / ECS / Docker / ALB / Route 53, Redis −35% bot path, RLS 3 tiers . One ECS task = Linux process(es) in a container. Scale-out = more tasks (processes), not more `new Thread()` on one JVM you did not run. Thread-safety question they may still ask in Java Live Code: request handlers share heap → `synchronized` / concurrent map / don’t mutate a global limiter unsafely (Rate Limiter is count=1 , other loop). 99.9%, sub-210 ms, Redis −35%, 3-tier RLS. Kubernetes is on the skills list — do not claim you operated a k8s thread scheduler here (see R20). I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Independent Rate Limiter SDE I count is 1, and that loop is OA plus system design, not UTA two-DSA. Ylogx shipped Redis at minus 35 percent bot DB latency, three-tier RLS, Docker on ECS, and CloudFront.

Example: Resume: FastAPI + NestJS, Postgres, 99.9% uptime, sub- 210 ms , CloudFront / ECS / Docker / ALB / Route 53, Redis −35% bot path, RLS 3 tiers .

If they probe: Kubernetes, I keep it conceptual and repeat that production was Docker on ECS with GitHub Actions CI/CD; I do not invent Fargate versus EC2 launch type unless I can confirm.

Spoken answer

Deadlock: wait-for cycle, no progress, threads BLOCKED . Livelock: threads RUNNABLE , keep reacting (unlock/retry/yield) but the invariant never advances. Polite philosophers put forks down forever; two `tryLock` fail and spin-retry with no backoff. Starvation: some thread never enters the CS (unfair lock, writer-preference, always-notify-wrong-waiter). Progress exists — just not for you. Fix livelock: backoff, random retry, lock order, `tryLock` + give-up to a queue. Horizon 60 FPS: livelock looks like busy pipeline, zero frames out. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Horizon 60 FPS: livelock looks like busy pipeline, zero frames out.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Intrinsic: `synchronized(obj) { while (!ok) obj.wait(); }` — `wait` releases the monitor ; must loop (`while`, not `if`) for spurious wakeups / stolen signal. Prefer `notifyAll` unless you can prove one waiter. `notify` vs `notifyAll`: wrong waiter wakes → lost signal. `notifyAll` is the interview-safe default. `ReentrantLock` + `Condition`: `await` / `signal` / `signalAll`. Extra: `tryLock`, `lockInterruptibly`, multiple conditions (notEmpty vs notFull) — cannot do that with one `Object` monitor cleanly. `synchronized` cannot `tryLock`. Nested `synchronized` in opposite order = Coffman cycle. Producer-consumer is the sketch (camera frames / KPI events). Do not claim you shipped `Condition` at Ylogx. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed.

Example: I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Why: cap threads, reuse, backpressure . `new Thread` per request = native stack + scheduler death. `ThreadPoolExecutor(core, max, keepAlive, queue, factory, handler)`. Queue full → create up to max → then RejectedExecutionHandler . `Executors.newFixedThreadPool(n)` = unbounded `LinkedBlockingQueue` → `max` never used; OOM under burst. `newCachedThreadPool` = unbounded threads. Interview: construct `ThreadPoolExecutor` yourself . Handler: `CallerRunsPolicy` (backpressure on caller), abort, discard. Daemon vs non-daemon: JVM exits when only daemons remain. Argus 20+ cameras / IQVIA LangGraph agents = bound the pool . Ylogx 99.9% is not “cached thread pool.”. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

Example: Argus 20+ cameras / IQVIA LangGraph agents = bound the pool .

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

`NEW` → `RUNNABLE` (includes OS running + ready) → `TERMINATED`. `BLOCKED`: waiting to enter `synchronized`. `WAITING`: `wait()` / `join()` / `LockSupport.park`. `TIMED_WAITING`: sleep / timed wait. Deadlock dump: `BLOCKED` + cycle. Livelock dump: `RUNNABLE`, no cycle. Tooling (`jstack`) is CS, not an internship bullet. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Generational: Eden → Survivor → Old . Hypothesis: most objects die young. Promotion if they survive collections. Stop-the-world vs concurrent marking (G1). You do not need CMS history. ZGC/Shenandoah = ultra-low pause, not intern evidence. Roots: stacks, statics, JNI. `finalize` is dead; `Cleaner` / try-with-resources for native. Java 8+: Metaspace (class metadata, native) replaced PermGen. `OutOfMemoryError: Metaspace` ≠ heap. Do not invent GC pause % for 99.9% / 99.5%. Those are service uptime.

Example: Stop-the-world vs concurrent marking (G1).

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Thread switch: save/restore registers + stack pointer; same page tables. Process switch: also CR3 / ASID — more TLB shootdown. Prefer threads for shared in-memory cache (one JVM). Prefer processes for blast radius (Argus worker, ROS2 node, ECS task). Green threads vs native: modern HotSpot 1:1 native . Virtual threads (Loom) = many tasks on few carriers — mention only if they ask Java 21; not on resume. Horizon nodes = process; Ylogx ECS task = process; in-process FastAPI/Nest workers = threads/async on a shared heap. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Process switch: also CR3 / ASID — more TLB shootdown.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

REST: Ylogx BI was REST (FastAPI + NestJS). JSON over HTTP; AuthN at API; RLS still in Postgres. Docker: package app + runtime. Ylogx: containers on ECS . Argus: containerized multi-cam workers. Not “I dockerized a laptop demo.”. EC2: VM that *can* run Docker. Honest: resume path is ECS managing containers , not “I SSH’d a fleet of EC2.” If they insist: ECS tasks still run on compute (Fargate or EC2 launch type) — I will not name which (off-resume). S3: object store (PDFs, model weights, static assets). Not a named Ylogx bullet. Contrast: Postgres = RLS rows / joins; S3 = blobs. Stratify/GiftedBooks *could* store models/PDFs as objects — do not invent a bucket name.

Example: EC2: VM that *can* run Docker.

If they probe: Kubernetes, I keep it conceptual and repeat that production was Docker on ECS with GitHub Actions CI/CD; I do not invent Fargate versus EC2 launch type unless I can confirm.

Spoken answer

Candidate listed an AWS-services task ; wording unnamed. Do not invent the task. Safe shape if they ask “which AWS did you use?”: CloudFront, ECS, Route 53, ALB (resume). Docker as the unit of deploy. Map each to a job: CDN/edge, container scheduler, DNS, L7 load balancer. Stop before a 12-service zoo (RDS name, ECR, ACM, WAF, EKS). Ylogx deploy sentence — that *is* the AWS-services answer. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. If the source did not name the prompt I keep a short pack ready and I do not guess the title.

Example: Safe shape if they ask “which AWS did you use?”: CloudFront, ECS, Route 53, ALB (resume).

If they probe: The exact wording is unnamed and I will not invent it; I offer the three-block pack or I write the DSA if the slot is actually code.

Spoken answer

Resolver asks recursive DNS; authoritative zone answers A/AAAA/CNAME/ALIAS. Ylogx hook: GoDaddy held the domain; Route 53 was the AWS DNS that aimed at the ALB . Registrar ≠ hosted zone. Same GFG slot also asked MAC vs IP, thrashing, virtual memory — not AWS. One line each if they chain: MAC = L2 local; IP = L3 routable; VM pages; thrashing = working set > RAM. GoDaddy + Route 53 + ALB. Not “I designed Route 53 geolocation.”. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Ylogx hook: GoDaddy held the domain; Route 53 was the AWS DNS that aimed at the ALB .

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Do not prep as if 18 Aug is an EC2-cost OA. If they still ask cost: Frugality = CloudFront + Redis before a larger box; no invented AWS bill. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. I stop after one example rather than inventing architecture I did not ship.

Example: Do not prep as if 18 Aug is an EC2-cost OA.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

A browser hits CloudFront, then ALB, then an ECS task running a Dockerized FastAPI or NestJS API, then Postgres with three-tier RLS, and Redis sits on the hot bot path. DNS is GoDaddy to Route 53 to that ALB. Dashboards are sub-210 ms and uptime is 99.9 percent. Redis cut bot DB latency 35 percent. CI/CD is GitHub Actions building the image and rolling ECS. The LLM SQL RAG is not on the dashboard hot path. Kubernetes is skills-only; this path is ECS. I do not invent Fargate versus EC2 launch type.

Example: Opening a KPI dashboard is CloudFront cache or origin to ALB to ECS to Postgres; asking the bot a question may hit Redis minus 35 percent then SQL under SET ROLE, which is a slower path on purpose.

If they probe: K8s ingress names, I map them conceptually to ALB plus ECS and repeat I did not run a cluster.

Spoken answer

CloudFront is a CDN at the edge so static and cacheable KPI JSON does not hit ECS on every repeat view, which is how you defend sub-210 ms. It also terminates TLS at AWS edge and hides origin. Frugality is cache before a bigger box. Nginx is on the skills list as the same reverse-proxy idea; the resume public edge is CloudFront plus ALB, not I put Nginx on the internet. Cache versus origin is the mental model: TTL on GET, no cache on tenant-specific POST. 99.9 percent still depends on ECS remaining healthy behind ALB. I do not invent a cache-hit percentage. Argus cameras are not this CDN path.

Example: Thirty dashboards that 60 percent more ops used would melt ECS if every widget missed the edge; CloudFront holds the cacheable GETs while ECS serves origin and the bot path uses Redis.

If they probe: An Nginx conf I shipped as the public edge, I correct to CloudFront plus ALB.

Spoken answer

Docker is the image and the running container. ECS is the scheduler: cluster, service, task, and task definition, so desired count stays N, health checks replace bad tasks, and rolling deploys happen without a screen session on a fat VM. That is what Ylogx shipped with CI/CD. Just docker run is not 99.9 percent. Kubernetes would also schedule containers; I did not operate it here. ALB targets ECS tasks, not random docker ps. Argus containerized 20-plus cameras is Docker isolation, not an ECS claim unless I am talking Ylogx. I will not invent CPU units.

Example: A GitHub SHA becomes a task definition revision; ECS starts a new task, ALB waits for slash health 200, then an old task stops, which docker run on one VM cannot do cleanly.

If they probe: Fargate versus EC2 launch type, I mark off-resume unless I can confirm.

Spoken answer

ALB = L7 (HTTP/HTTPS) load balancer. Host/path rules; health checks; drain on deploy. Route 53 points at the ALB, not at a single task IP (tasks die). Not NLB (L4) unless they ask the contrast — resume names ALB. Host-header / www vs non-www isolation is how “the site is up but Google 403s” actually fails (prep class of bug; no fake ticket ID). “GoDaddy DNS with Route 53 to route traffic through an ALB.”. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: ALB = L7 (HTTP/HTTPS) load balancer.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

GoDaddy: registrar (bought the name). Can also do DNS; we used AWS DNS for the ALB alias. Route 53: hosted zone; alias/A to ALB (AWS-native target). Cutover: point GoDaddy NS (or relevant records) at Route 53 so AWS is authoritative for the app hostname. Debug order if the site “vanishes”: registrar NS → Route 53 records → ALB listener/certs → CloudFront alternate domain → origin. Isolate, don’t reboot ECS first. Configured GoDaddy DNS with Route 53. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Route 53: hosted zone; alias/A to ALB (AWS-native target).

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

GitHub Actions is the intern CI/CD: test, image, deploy to ECS. The image tag is the commit SHA so I can roll forward or back. ECS keeps a desired count and replaces tasks behind ALB health checks. CloudFront continues to cache the dashboard during a short overlap. Secrets are injected, never committed. I do not claim a 20-stage textbook pipeline. 99.9 percent is compatible with a two-minute overlapping roll and not with taking the service to zero. Kubernetes rollingUpdate is the analogue I can name without claiming I ran it.

Example: Main branch push runs pytest, docker build, docker push, then register task definition and update-service; ALB stops sending traffic to 503 tasks.

If they probe: Ask for the YAML, I sketch steps and refuse to invent OIDC ARNs.

Spoken answer

Resume-stated p-ish latency, not a load-test dump I do not have. Budget: CloudFront cache for static; Redis for hot schema/repeat bot queries (−35% DB latency); connection pooling; no LLM on the dashboard hot path . SQL RAG is slower than a cached KPI GET — do not pretend every chatbot token is 210 ms. If they ask p99: I measured to put sub-210 ms on the resume; I will not fabricate percentiles. “achieving sub-210 ms response times.”. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Budget: CloudFront cache for static; Redis for hot schema/repeat bot queries (−35% DB latency); connection pooling; no LLM on the dashboard hot path .

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Meaning: health checks, rolling deploys, don’t SSH-mutate prod, ALB only healthy targets. Not multi-AZ claimed. GiftedBooks is 99.5% (different product; don’t mix). Incidents I will discuss as a *class*: DNS/host-header/CloudFront vs origin, not a named SEV. BI that is down is not “AI” (Deliver Results / Highest Standards backup). “99.9% uptime” on Ylogx daily queries. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: GiftedBooks is 99.5% (different product; don’t mix).

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Kubernetes is on the skills list; I am not a cluster owner. What I actually ran is Docker on ECS with CloudFront, ALB, Route 53, GitHub Actions CI/CD, Redis minus 35 percent, and 99.9 percent uptime at Ylogx. Ingress in k8s is the same reverse-proxy idea as Nginx or ALB. I can talk Deployments, Services, and rollingUpdate as standard CS. I will not fake kubectl against a named account. Argus containerized 20-plus cameras is not EKS. GiftedBooks 99.5 percent is not this ECS story. I keep that honesty even if they push.

Example: If they ask how I would roll out, I describe ECS starting a new task, waiting until ALB is healthy, then stopping an old task, and I can say the k8s analogue is a Deployment without claiming I ran it.

If they probe: Want EKS node groups, I stop rather than invent.

Spoken answer

Argus: YOLOv9, 20+ cameras, 24 FPS , Postgres logs, containerized . Scale = workers per stream, not an ALB/CloudFront story. Ylogx: HTTP BI, CloudFront/ECS/ALB, sub-210 ms . Don’t paste the Ylogx diagram onto Argus, or GPU onto Ylogx. Argus containerized 20+ cams; Ylogx ECS. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Argus is YOLOv9 on more than 15,000 images, 73 percent to 89 percent mAP, 24 FPS, and more than 20 cameras, and I do not put an LLM on PPE boxes. Ylogx shipped Redis at minus 35 percent bot DB latency, three-tier RLS, Docker on ECS, and CloudFront. Horizon is ROS2 with a GStreamer 60 FPS feed, and I do not put an LLM on the costmap or actuation.

Example: Argus: YOLOv9, 20+ cameras, 24 FPS , Postgres logs, containerized .

If they probe: Kubernetes, I keep it conceptual and repeat that production was Docker on ECS with GitHub Actions CI/CD; I do not invent Fargate versus EC2 launch type unless I can confirm.

Spoken answer

Task role / env for DB URL. LLM must not hold a superuser connection. NestJS RBAC + Postgres RLS, 3 org tiers . Scaling ECS without RLS scales leaks . Parameterized SQL, read-only role, timeout, row cap. RLS/RBAC 3 tiers + ECS deploy. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. IQVIA is LangGraph Deep Research across 200-plus sites and Hybrid RAG on 200-plus page BRDs with LangSmith traces and evals. Ylogx shipped Redis at minus 35 percent bot DB latency, three-tier RLS, Docker on ECS, and CloudFront.

Example: NestJS RBAC + Postgres RLS, 3 org tiers .

If they probe: Where not to use an LLM, I name Ylogx RLS, Argus PPE boxes, and Horizon costmap; if the slot is labeled GenAI Fluency but is Distance K, I write the tree, not a RAG essay.

Spoken answer

VM: hypervisor, guest kernel, heavier. Container: shared host kernel, isolated processes + filesystem (namespaces/cgroups). Image = layers + entrypoint; container = running instance. Why Docker for Ylogx: same artifact from CI to ECS. Why not a snowflake EC2 AMI as the first cut. Docker containers on ECS. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Why not a snowflake EC2 AMI as the first cut.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Task def: image, CPU/mem, ports, env. Service: keep desired count; attach load balancer. Cluster: pool the service runs in. Scale = desired count (horizontal), not “resize the laptop.”. ECS service behind ALB — I will not invent desired-count numbers. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Ylogx shipped Redis at minus 35 percent bot DB latency, three-tier RLS, Docker on ECS, and CloudFront.

Example: I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

If they probe: Kubernetes, I keep it conceptual and repeat that production was Docker on ECS with GitHub Actions CI/CD; I do not invent Fargate versus EC2 launch type unless I can confirm.

Spoken answer

ALB: HTTP(S), host/path, sticky optional, health checks. NLB: TCP/UDP, extreme connections, not the BI default. Nginx: skills list (reverse proxy/static). Not named on the Ylogx AWS bullet — don’t put Nginx in the diagram unless they ask skills. ALB named; Nginx = skills only. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Cache key ≈ URL (+ headers you chose). Hit = edge; miss = origin (ALB/ECS). Invalidation after frontend deploy, or versioned asset names. Cookie/Authorization often bypass cache — authenticated API is not a 210 ms CDN miracle. CloudFront for static/API edge; Redis for origin DB. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Ylogx shipped Redis at minus 35 percent bot DB latency, three-tier RLS, Docker on ECS, and CloudFront.

Example: Cookie/Authorization often bypass cache — authenticated API is not a 210 ms CDN miracle.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Alias (AWS): name → ALB/CloudFront without a naked-CNAME headache. NS: who is authoritative. TTL: how long lie lives after a cutover. Do not claim geolocation / failover routing (multi-region-adjacent). Route 53 after GoDaddy. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Route 53 after GoDaddy.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Start v2 tasks → ALB health pass → shift traffic → stop v1. Don’t SIGKILL the fleet. Health check = HTTP path that means “can serve,” not “process exists.”. 99.9% is this discipline plus boring DNS, not a multi-region active-active (not on resume). CI/CD + 99.9% uptime. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Start v2 tasks → ALB health pass → shift traffic → stop v1.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Vertical: bigger task CPU/mem — Frugality last. Horizontal: more ECS tasks behind ALB. Cache (Redis −35%) and CDN first. I did not shard Postgres. Redis + CloudFront before a larger box. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python. Horizon is ROS2 with a GStreamer 60 FPS feed, and I do not put an LLM on the costmap or actuation.

Example: Cache (Redis −35%) and CDN first.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Stateless HTTP, resource URLs, JSON. Ylogx dashboards: REST, not GraphQL-first (GraphQL is skills; over-fetch wasn’t the first pain). Idempotent GET for KPIs; POST for report generate. RESTful APIs on the Ylogx bullet. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

Postgres: rows, joins, RLS, transactions. Redis: hot keys, TTL, −35% bot DB latency. S3 (if asked): immutable blobs, no RLS-over-SQL. Don’t store tenant fact tables in S3 and call it BI. Postgres + Redis shipped; S3 only if they ask the IE list. I only quote August 2026 resume metrics, and I do not invent headcount, GPU names, p99 dumps, or extra percentages. Job 10454435 still has no public named live question, so unnamed stays unnamed. Live Code is Java, and I name the production language honestly when the shipped stack was Python.

Example: Redis: hot keys, TTL, −35% bot DB latency.

If they probe: I give one concrete example, quote only resume metrics, and I stop before inventing a Job 10454435 question.

Spoken answer

FastAPI, NestJS, REST, Postgres, Redis, RLS/RBAC three tiers, CloudFront, ECS, Docker, ALB, Route 53, automated CI/CD; 40% faster reports, 99.9%, +65%, −35%, 30 dashboards +60%, sub-210 ms. Lead with shipped ownership before conceptual familiarity. Do not copy one project’s services or metrics onto another. Live Code remains Java even where production was Python/TypeScript/ROS2. State the unsupported boundary directly instead of guessing.

Spoken answer

Python/FastAPI, LangGraph, Azure AI Search hybrid+semantic, GraphDB, LangSmith; 200+ sites and 200+ page BRDs. Lead with shipped ownership before conceptual familiarity. Do not copy one project’s services or metrics onto another. Live Code remains Java even where production was Python/TypeScript/ROS2. State the unsupported boundary directly instead of guessing.

Spoken answer

Python/OpenCV/YOLOv9, 15k+ images, 73→89% mAP, 24 FPS, 20+ feeds, Postgres logs, containerized, −50% violations, 2× compliance. Lead with shipped ownership before conceptual familiarity. Do not copy one project’s services or metrics onto another. Live Code remains Java even where production was Python/TypeScript/ROS2. State the unsupported boundary directly instead of guessing.

Spoken answer

ROS2/Python/native GStreamer/ZED, 60 FPS, 2M+ points/s, +40% obstacle detection, −55% collision, ERC 17th/80+. Lead with shipped ownership before conceptual familiarity. Do not copy one project’s services or metrics onto another. Live Code remains Java even where production was Python/TypeScript/ROS2. State the unsupported boundary directly instead of guessing.

Spoken answer

Auth0 vendor ownership, Kubernetes/EKS, Nginx as production edge, Mongo/Firebase warehouse, S3 buckets, Kafka operations, sharding, WebSocket fan-out, Prisma as Ylogx ORM. Lead with shipped ownership before conceptual familiarity. Do not copy one project’s services or metrics onto another. Live Code remains Java even where production was Python/TypeScript/ROS2. State the unsupported boundary directly instead of guessing.