189 DevOps Engineer Interview Questions & Answers

I would read the JSON array, validate every entry, and use a dictionary to count events for each user ID. I increment the count once for every valid entry, then sort the unique user IDs lexicographically before building the output object. I write that object to a temporary file and atomically replace the final report so a failure cannot publish partial output. The time is O(n + u log u). The count and output structures use O(u) space, plus O(n) for the parsed input.

The script reads one local activity file and creates a report showing how many entries belong to each user. Every entry must contain a non-empty user ID. Repeated entries count again. The report must list user IDs in lexicographic order. The input file must stay unchanged. The script first creates a temporary report and only replaces the final report after writing succeeds. Bad input exits with code 2. Unexpected file problems exit with code 1. A successful run reports the entry and user totals and exits with code 0.

1. Should extra fields in each activity entry be ignored? Yes. Only user_id is required for counting.
2. Should an existing report stay unchanged when input validation fails? Yes. The required behavior is to leave it unchanged.

The program takes no command-line arguments. It reads /home/interview/activity_logs.json. The top level must be a JSON array. Every element must be an object with a non-empty string user_id. Other fields are allowed. Repeated entries count separately.

The program writes /home/interview/user_event_counts.json. This file contains one JSON object. Each key is a user ID. Each value is that user's number of entries. The keys must be in lexicographic order. An empty input array produces {}.

I start with an empty dictionary named counts. The key is a user ID. The value is the number of valid entries seen for that user.

The central invariant is simple. After processing any valid prefix of the array, counts[user_id] equals the number of processed entries for that user.

For each entry, I first check that it is an object. Then I read user_id and check that it is a non-empty string. If either check fails, I print an error to stderr and return exit code 2 before publishing any new report.

For a valid entry, I update the count with counts[user_id] = counts.get(user_id, 0) + 1.

The input is [{"user_id":"user_456","event":"view"},{"user_id":"user_123","event":"login"},{"user_id":"user_123","event":"logout"}].

After the first entry, the state is {"user_456": 1}.

After the second entry, the state is {"user_456": 1, "user_123": 1}.

After the third entry, the state is {"user_456": 1, "user_123": 2}.

Next, I sort the user IDs lexicographically. The order becomes user_123, then user_456. The final JSON data is {"user_123":2,"user_456":1}.

After all validation and counting succeed, I build a new result object using the sorted keys. I create a temporary file in the same directory as the final report. I write the complete JSON object there first. I flush the file and call os.fsync so the temporary file data is handed to the operating system for writing.

Then I call os.replace to replace /home/interview/user_event_counts.json. Because the temporary file is created in the same directory, the local rename is atomic. A reader sees either the previous complete report or the new complete report, not a partly written report.

A missing input file, malformed JSON, wrong top-level type, or invalid entry prints an error to stderr and exits with code 2. These failures happen before publication, so an existing report is not replaced.

Other unexpected input or output I/O failures print an error to stderr and exit with code 1. If an unpublished temporary file exists after an output failure, the code tries to remove it.

On success, the script prints the total number of entries and unique users to stderr and exits with code 0.

The counts are correct because every valid entry increments exactly one user's count by one. Repeated entries therefore count separately. Sorting the unique user IDs before building the result gives the required key order. Writing to a temporary file before os.replace prevents a partial final report from being published. The generated JSON is deterministic, so unchanged input produces the same JSON data on a rerun.

For n input entries and u unique users, reading and counting takes O(n) time. Sorting takes O(u log u) time. Total time is O(n + u log u). The count and output structures use O(u) additional space. The parsed input uses O(n) space. Important edge cases are an empty array, repeated users, invalid entries, malformed JSON, a missing input file, and unexpected I/O failures.

Use one pass over the parsed JSON array and store counts in a Python dictionary. Each key is a user_id. Each value is the number of valid entries seen for that user. The central invariant is that after processing any valid prefix of the input, every stored count exactly matches the number of processed entries for that user. After counting, sort the unique user IDs and build the result in that order. This separates counting from the required output ordering. Finally, write the complete result to a same-directory temporary file and use os.replace so the final report is published atomically.

The program defines fixed input and output paths because the task takes no arguments. main() first opens and parses the input JSON. A missing file or malformed JSON returns exit code 2. Other unexpected input I/O problems return 1. The code then checks that the top level is a list. It validates each entry and increments counts[user_id] once per entry. After counting, it creates result from lexicographically sorted user IDs. It creates a temporary file in the output directory, writes the JSON, flushes and syncs it, and calls os.replace for atomic publication. If output I/O fails, it returns 1 and tries to remove any unpublished temporary file. On success, it logs the number of entries and users to stderr and returns 0.

A common mistake is counting only distinct events instead of counting every entry. Another is accepting an empty user_id or a non-object entry. Candidates may sort or otherwise change the input even though the input must never be modified. Another mistake is writing directly to the final report path, which can expose partial output after a failure. It is also easy to return exit code 2 for every I/O problem instead of using exit code 1 for unexpected I/O failures. Finally, forgetting the O(u log u) key-sorting cost gives the wrong complexity.

Explain the solution in three stages: validate and count, sort the user IDs, then publish with a temporary file and atomic rename. This makes both the counting logic and the failure-safety requirement easy for the interviewer to follow.

I would read the fixed INI file with Python configparser and disable interpolation. After parsing succeeds, I would require the database section and copy only its key-value pairs into a dictionary. ConfigParser makes option names lowercase, while all values stay as strings. I would serialize that dictionary deterministically, write it to a temporary file in the output directory, and atomically replace config.json. Input or parsing problems exit 2, other I/O errors exit 1. The solution takes O(N) time and O(N) auxiliary space.

The script reads one fixed configuration file and creates one JSON file. It must copy only the information inside the database section. Other sections are ignored. Database names become lowercase in the output, while their values stay as text. Bad input must not damage an existing output file. The script therefore reads and checks the whole input first. It then builds deterministic JSON, writes the complete result to a temporary file, and replaces the real output only after that write succeeds. This keeps the operation safe and repeatable for unchanged input.

1. Should an existing config.json remain unchanged for every input or parsing error?
2. Should the success summary and every error message be written only to stderr?
3. Is preserving every database value as a string required even when a value looks numeric?

The program takes no arguments. It always reads /home/interview/config.ini. I create configparser.ConfigParser with interpolation=None, so values are read literally. Blank lines and normal # or ; comment lines are accepted by ConfigParser. The parser is strict, so duplicate sections and duplicate option names are rejected. A missing input file, UTF-8 decode failure, duplicate definition, or malformed INI file produces a diagnostic on stderr and exit code 2. Other I/O failures use exit code 1.

After parsing succeeds, I check whether [database] exists. If it is missing, I print a diagnostic to stderr and return exit code 2. This check happens before any output replacement, so an existing /home/interview/config.json stays unchanged.

I read all items from [database] into a Python dictionary. ConfigParser normalizes option names to lowercase by default. It also keeps the values as strings. Other sections are never copied. In the diagram example, the database section contains host=localhost, port=5432, name=appdb, and user=admin. A separate server section is ignored.

The dictionary is serialized in its stable insertion order. ConfigParser preserves the option order read from the INI file, and Python dictionaries preserve insertion order. For the shown input, the JSON data is {"host":"localhost","port":"5432","name":"appdb","user":"admin"}. Running the script again with the unchanged input produces the same JSON bytes.

I create a temporary file in the same directory as config.json. I write the complete JSON to that file, flush it, and call os.fsync. Only then do I call os.replace to atomically replace config.json. If creating, writing, flushing, or replacing the temporary file fails, I print an error to stderr, remove the temporary file when possible, and exit 1. The old output is never replaced by a partial file.

After os.replace succeeds, the script prints one summary line to stderr and returns 0. There is no network operation, timeout, or retry. If N is the size of the INI input, the work is O(N). ConfigParser stores parsed data, and the script also stores the selected dictionary and JSON text, so auxiliary space is O(N). The main invariant is that config.json is replaced only after parsing, validation, serialization, and the temporary-file write have all succeeded.

The solution follows a validate-then-replace pattern. First, ConfigParser reads the INI file with interpolation disabled and strict duplicate checking. Next, the script verifies that [database] exists and copies only that section into a dictionary. ConfigParser supplies lowercase option names, and values remain strings. The dictionary is serialized deterministically. The central invariant is that the existing config.json is not replaced until the complete new JSON has been successfully written to a temporary file. A same-directory temporary file followed by os.replace provides the atomic replacement shown in the diagram.

The program defines the fixed input and output paths and then runs main(). It creates a ConfigParser with interpolation disabled. The input is opened as UTF-8 and parsed with read_file(). FileNotFoundError, UnicodeDecodeError, and configparser.Error are treated as input or format problems and return 2. Other OSError failures while reading return 1.

After parsing, the code checks for the required database section. If it is absent, it returns 2 before touching the output. It converts parser.items("database", raw=True) into a dictionary. ConfigParser has already normalized option names to lowercase, and the values remain strings.

json.dumps creates compact deterministic JSON. The dictionary preserves the INI option order, so the diagram example is written as {"host":"localhost","port":"5432","name":"appdb","user":"admin"}. A trailing newline is added consistently.

For the atomic write, tempfile.mkstemp creates a temporary file in the same directory as config.json. The script writes the full JSON, flushes it, calls os.fsync, and then uses os.replace. If an I/O failure happens before successful replacement, the temporary file is removed when possible and the function returns 1. After successful replacement, the script prints exactly one summary to stderr and returns 0.

1. Forgetting interpolation=None and accidentally allowing ConfigParser interpolation.
2. Exporting every section instead of only [database].
3. Converting values such as 5432 to numbers even though all values must remain strings.
4. Changing ConfigParser's lowercase option-name behavior and producing keys with the wrong case.
5. Writing directly to config.json before parsing and validation finish, which can damage an existing valid output.
6. Using the wrong exit code or writing operational messages to stdout instead of stderr.

Explain the order of operations clearly: parse the entire input, validate [database], build the JSON, write a complete temporary file, and only then atomically replace config.json. That sequence shows both scripting skill and production-safe failure handling.

I would stream the URL file as UTF-8, strip each line, ignore blanks, and apply the required regular expression to every non-empty line. A match writes capture group 1 to a temporary file exactly as found. A non-match is logged by line number, but processing continues. After successful processing, I atomically replace the final output. The total time is O(n). Memory does not grow with total file size, although Python holds the current line in memory.

The script reads URL lines from /home/interview/urls.txt. It ignores blank lines. For each non-empty line, it checks whether the beginning contains a valid scheme followed by a domain. If the regex matches, only the captured domain is written. Case, subdomains, order, and duplicates stay unchanged. Invalid non-empty lines are logged and skipped, but later valid lines are still processed. The completed valid result is published atomically. Missing input, malformed UTF-8, or bad invocation must leave any existing output unchanged.

1. Should the final input, match, and skip counts go to standard output while skipped-line and error messages go to standard error?

The script is /home/interview/extract_domains.py and accepts no arguments. It reads /home/interview/urls.txt as UTF-8. For each stripped, non-empty line, it applies [A-Za-z]+://([^/:]+). Capture group 1 is the domain. The scheme, port, path, and query are not written. The final file is /home/interview/domains.txt, with one captured domain per line.

The script creates a temporary file in the same directory as the final output. This temporary file receives all valid domains. Using the same directory lets os.replace publish the completed file with atomic replacement semantics. Until that final replacement happens, the existing /home/interview/domains.txt is not changed.

Each raw line is stripped. Blank lines are ignored and do not increase the input count. Every remaining line increases input_count exactly once. The regex is applied with match, so matching starts at the beginning of the stripped line. If it matches, group(1) is written exactly as found and match_count increases. If it does not match, skip_count increases and the 1-based line number is logged. Processing continues after a skipped line.

Line 1, https://www.example.com/path, captures www.example.com. Line 2, http://api.service.org:8080/endpoint, captures api.service.org, so port 8080 is excluded. Line 3 captures files.company.co.uk. The blank line is ignored. Line 5, invalid_line_without_scheme, does not match, so it is logged and skipped. Line 6, HTTPS://Sub.Domain.com:443/abc?x=1, captures Sub.Domain.com. The final counts are 5 non-empty input lines, 4 matches, and 1 skip.

After all valid processing succeeds, the script logs the input, match, and skip counts and calls os.replace to publish the temporary file as /home/interview/domains.txt. The four domains from the example are therefore written even though one non-empty line was skipped. The script exits 0 when skip_count is 0. It exits 1 when one or more non-empty lines were skipped.

Bad invocation, missing input, and malformed UTF-8 return exit code 2. The temporary file is removed and the existing output is not replaced. Other unexpected I/O failures return 1 and also avoid publishing partial output. A failure while creating the temporary file returns 1. A failure during final os.replace also returns 1.

The invariant is that the temporary output contains exactly the captured domains from successfully matched non-empty lines processed so far, in original order and with original spelling. Each input character is examined only a constant number of times, so total time is O(n), where n is the file size in characters. The diagram describes the solution as streaming with O(1) extra space relative to total file size. More precisely, Python temporarily holds the current line and stripped string, so transient memory is O(L), where L is the longest line.

Use a streaming read-transform-write pipeline. Create a temporary output in the same directory as the final file. Then read the input line by line. Strip each line and ignore blanks. For every non-empty line, apply [A-Za-z]+://([^/:]+). A match contributes capture group 1 directly to the temporary file. A non-match is logged and counted, but does not stop later processing. The central invariant is that the temporary file always contains exactly the matched domains processed so far, in their original order, case, and duplicate count. After successful processing, os.replace atomically publishes the completed result.

The program first checks that no command-line arguments were supplied. It then creates a temporary file beside /home/interview/domains.txt. Next, it opens /home/interview/urls.txt as UTF-8. Each line is stripped. Blank lines are ignored. Every non-empty line increases input_count and is matched with the required regex. A match writes capture group 1 immediately to the temporary output and increases match_count. A non-match logs its 1-based line number and increases skip_count. Missing input and malformed UTF-8 return 2 after temporary-file cleanup. Other I/O failures return 1. When processing succeeds, counts are logged and os.replace publishes the completed temporary file. The final status is 0 when no line was skipped and 1 otherwise.

A common mistake is changing the required regex instead of using [A-Za-z]+://([^/:]+). Another is lowercasing domains, removing duplicates, or changing their order. Candidates may accidentally count blank lines, stop after the first non-matching line, or forget that valid domains must still be published when skips occur. Another serious mistake is writing directly to the final output file, because an error could leave partial output. It is also easy to return the wrong exit code for missing input, malformed UTF-8, or an unexpected I/O failure.

Explain the temporary-file rule before showing the loop. Say that recoverable bad lines are logged while processing continues, but fatal file or encoding errors prevent os.replace. This makes the atomic-output and exit-code behavior easy for the interviewer to verify.

I would implement this as a streaming Bash filter. I first reject arguments and validate TIMESTAMP_NOW before reading stdin. Then I read one line at a time with IFS= read -r, choose either the fixed test timestamp or the current local time, and write the result immediately. I increment the completed count only after a successful write. Clean EOF exits

1. Read or write failure exits
2. The solution is O(n) time and O(1) auxiliary space.

The script receives text from standard input as a stream. For every line, it keeps the original content and adds a timestamp in YYYY-MM-DD HH:MM:SS format. It writes each result immediately, so lines that arrive later can receive later timestamps. A valid TIMESTAMP_NOW value gives deterministic test output. Arguments or an invalid override are rejected before input is read. The script tracks only successfully written lines. Clean EOF is success. Read or write failure reports the completed count and exits with an error.

1. Should TIMESTAMP_NOW be accepted only when it has the exact YYYY-MM-DD HH:MM:SS format and represents a real local date and time?
2. On a read or write failure, should the script stop immediately without retrying?
3. Should the script wait indefinitely for additional stream input instead of using an idle timeout?

The script must accept no arguments. If an argument is present, it writes an error to stderr and exits 2 before reading stdin. If TIMESTAMP_NOW is set, the script first checks the exact YYYY-MM-DD HH:MM:SS shape. It also uses GNU date to confirm that the value is a real date and time. An invalid override also exits 2 before reading.

The completed-line counter starts at 0. The script also records whether a validated TIMESTAMP_NOW override is active. The important invariant is that count always equals the number of output lines that completed successfully.

The script repeatedly calls IFS= read -r line inside a conditional so set -e does not terminate the script before the read status can be examined. A read status of 0 means a line was received. Status 1 means clean EOF in the illustrated solution. Any other read status is treated as an I/O failure.

For every successfully received line, the script chooses its timestamp at that point. If the fixed override is active, it uses TIMESTAMP_NOW. Otherwise, it calls date '+%Y-%m-%d %H:%M:%S'. Because the live timestamp is obtained inside the loop, delayed input can receive a different time.

The script writes exactly one result with printf '%s - %s\n' "$line" "$ts". There is no retry and no application-level batching. If printf fails, the script reports how many earlier lines completed and exits 1. The counter increases only after the output operation succeeds.

On clean EOF, the script logs the completed-line count to stderr and exits

1. A read failure logs the completed count and exits
2. A write failure does the same. There is no idle timeout because stdin is intentionally treated as a stream.

The input contains Application started followed by Request completed. TIMESTAMP_NOW is 2026-08-28 15:30:45. The first line therefore becomes Application started - 2026-08-28 15:30:45. The second becomes Request completed - 2026-08-28 15:30:45. Order is preserved and both output lines use the same deterministic timestamp.

For n input lines, the diagram shows O(n) time because each received line is processed once. Auxiliary space is O(1) because the script keeps only the current line, timestamp, status values, and counter. Empty lines, duplicates, spaces, and backslashes are preserved. Normal mode is intentionally time-dependent. Fixed-time mode is deterministic and idempotent for the same input.

Use a single streaming loop. Validate all startup conditions before touching stdin. Then perform the same sequence for every received line: read it safely, choose its timestamp, write one formatted result, and increment the counter only after the write succeeds. The central invariant is that count equals the number of fully completed output lines. This makes failure reporting accurate. The read status is captured explicitly so clean EOF and an I/O failure can follow different exit paths.

Let n be the number of input lines. The time complexity is O(n) because each received line is handled once. Auxiliary space is O(1) because the script does not collect the stream in memory. It keeps only the current line, one timestamp, a few status variables, and the completed-line counter. The script may wait indefinitely for another input line because the design intentionally has no idle timeout.

The final implementation is Bash because the question specifically requires the executable /usr/local/bin/timestamp.sh. The script starts with set -euo pipefail and rejects any command-line arguments. It then validates TIMESTAMP_NOW before reading stdin. The validation checks both the exact text shape and a GNU date round trip so impossible dates or times are rejected.

The main loop performs IFS= read -r line inside an if statement. This lets the script capture the read status without set -e stopping execution. Status 0 enters the normal processing path. Status 1 is treated as clean EOF in the illustrated solution. Other statuses are read failures.

For a successful read, the timestamp is chosen immediately. A validated override is reused in fixed-time mode. Otherwise, date is called for the current local time. The script then performs one printf for the output line. If that write fails, it logs the number of earlier completed lines and exits 1. Only a successful write increments count.

Clean EOF logs completed count and exits

1. A read failure logs completed count and exits
2. There are no write retries and no idle timeout.

1. Reading stdin before checking arguments or TIMESTAMP_NOW. Invalid startup input must exit 2 before any read.
2. Checking only the timestamp pattern and accepting impossible dates or times.
3. Using read as an unconditional command under set -e and losing the chance to inspect its failure status.
4. Incrementing count before the output succeeds. That makes the completed-line count wrong after a write failure.
5. Using echo or unsafe reading that changes spaces, backslashes, or empty-line behavior instead of IFS= read -r and printf.
6. Buffering the whole input, retrying failed writes, or adding an idle timeout even though the required design is a live stream.

Explain the completed-line invariant first: count means lines that were successfully written, not merely lines that were read. Then explain the three exit classes clearly: invalid startup input exits 2 before reading, read or write failure exits 1 with the completed count, and clean EOF logs the count and exits 0.

I would use find from / with its default -P behavior, -xdev, and -nouser. I capture each accessible orphan entry as its numeric UID and full path, suppress traversal diagnostics, and sort the matches with LC_ALL=C by numeric UID and then bytewise path. I print nothing when there are no matches. Complete traversal logs the count to stderr and exits 0. Incomplete traversal exits 1 after printing accessible results. Invalid usage or startup failure exits 2.

The script must start at / and find filesystem entries owned by numeric user IDs that no longer have matching user accounts. It must stay on the filesystem containing / and must not follow symbolic links into other trees. Every accessible match is printed as its numeric UID, one space, and its full path. The lines are ordered by numeric UID and then bytewise path. Permission diagnostics are hidden. A complete scan logs the count to stderr. An incomplete scan still prints accessible matches and exits 1. The script performs no retries, network operations, or writes.

1. Should the search stay only on the filesystem containing /? Yes. The required command uses -xdev.
2. Should permission errors discard results that were already accessible? No. Accessible matches must still be printed.
3. How should paths be ordered when two entries have the same UID? Use bytewise path order with the C locale.

The script accepts no arguments. If any argument is supplied, it exits 2. Before traversal, it checks that / is readable and searchable. An unusable root also exits 2. It then checks that the find command is available. If traversal cannot be started for this reason, the script exits 2.

The scan starts at /. find uses its default -P behavior, so it does not follow symbolic links. The -xdev option keeps traversal on the filesystem containing /. The -nouser test selects entries whose numeric owner UID has no matching user account. -printf '%U %p\n' produces the numeric UID followed by the full path. Diagnostics are redirected to /dev/null, while successfully found matches remain available.

The script saves the exit status from find immediately. A status of 0 means traversal completed. A nonzero status after traversal started means the traversal was incomplete.

The captured records are sorted with LC_ALL=C sort -k1,1n -k2. The first key is numeric, so owner UIDs are compared as numbers. The second key starts at the full path and uses the C locale, so paths are ordered bytewise. If this required sorting stage fails, the script exits 2 rather than reporting a successful run.

The example contains /srv/legacy/a.log and /srv/legacy/b.log. Both entries are owned by UID 5001. There is no matching user account for UID 5001, so both entries satisfy -nouser.

The required stdout is: 5001 /srv/legacy/a.log 5001 /srv/legacy/b.log

Both records have the same UID. The bytewise path key therefore places a.log before b.log.

If sorted output is non-empty, the script prints it to stdout. If there are no matching entries, it prints zero bytes to stdout and keeps the result count at zero.

If find completed successfully, the script prints the numeric result count to stderr and exits

1. If traversal started but find returned nonzero, all accessible matches have already been printed and the script exits
2. It does not retry the traversal.

The central invariant is that every collected record came from an accessible filesystem entry selected by find -nouser while traversal stayed on the filesystem containing /. Each record contains that entry's numeric owner UID and full path. Sorting changes only record order. It does not add or remove matches. Suppressing diagnostic messages also does not suppress successfully collected results.

The illustrated solution uses O(N log N) time for sorting N matched orphan entries and O(N) auxiliary space for the captured and sorted matches. Important edge cases are no matches, permission-denied or otherwise inaccessible subtrees, an unusable root, supplied arguments, inability to start find, sorting failure, and incomplete traversal.

The solution separates the work into traversal, filtering, ordering, and exit handling. find begins at /, keeps its default -P symbolic-link behavior, uses -xdev to stay on the starting filesystem, and uses -nouser to select entries whose owner UID has no matching account. Each selected entry becomes a numeric_uid full_path record. The central invariant is that every collected record represents an accessible entry that satisfied -nouser. LC_ALL=C sort -k1,1n -k2 then orders those records by numeric UID and full path without changing which entries were found.

The required solution is an executable Bash script at /home/interview/find-orphans.sh. It first rejects arguments with exit 2. It checks that / is readable and searchable, then checks that find is available. Next it runs find / -xdev -nouser and formats every accessible match as numeric UID plus full path while sending diagnostics to /dev/null. The script saves find's exit status before doing any later work. It sorts captured records with LC_ALL=C sort -k1,1n -k2 and treats sorting failure as exit 2. It prints sorted output only when non-empty, so a no-match run writes nothing to stdout. It counts actual result lines. Complete traversal logs that count to stderr and exits 0. Incomplete traversal exits 1 after accessible results have been printed. No retry is performed.

A common mistake is forgetting -xdev and crossing into mounted filesystems. Another is claiming that -xdev prevents symbolic-link following, when that behavior comes from find's default -P mode. Candidates may also use the wrong sort keys, fail to save find's exit status immediately, print a blank line when there are no matches, discard accessible results after permission errors, log a success count after incomplete traversal, or return exit 0 when traversal was incomplete. Retrying after a traversal error would also violate the stated contract.

Explain the exit codes as three separate states: exit 2 means the script could not validly start or complete required startup processing, exit 1 means traversal started but was incomplete after accessible results were printed, and exit 0 means traversal completed and the result count was logged to stderr.

I would validate /home/interview/repo and the two required local refs first, without fetching anything. Then I would run git log --oneline --no-merges origin/main..feature-api and write its output to a temporary file beside the final output. Only after Git succeeds would I atomically rename that file to /home/interview/unique-commits.txt. I would then count and log the commits. The revision walk is O(V + E), while writing and storing k emitted lines is O(k).

The script takes no arguments. It works in /home/interview/repo. It requires the existing local refs feature-api and origin/main, and it must not fetch from the network. It saves commits that are reachable from feature-api but not reachable from origin/main. Merge commits are excluded. Each output line contains an abbreviated commit hash and subject, newest first. A missing repository or required ref exits 2 without replacing an existing output. Another Git or I/O failure exits 1. A successful run writes atomically, logs the commit count, and exits 0.

1. Should origin/main mean only the existing local remote-tracking ref, with no fetch? Yes, that matches the requirement.
2. If there are no unique non-merge commits, should the script replace the output with an empty file? Yes.
3. Should the existing output remain untouched until the complete Git command succeeds? Yes, because the required write is atomic.

I first check that /home/interview/repo exists. If it is missing, I exit 2 before creating a temporary file, so an existing output is not replaced. I then enter the directory and verify that Git can use it as a repository. I check the exact local refs refs/heads/feature-api and refs/remotes/origin/main. A missing required ref exits 2. Another Git or I/O failure exits 1. I never run git fetch, so there is no network timeout or retry.

The main command is git log --oneline --no-merges origin/main..feature-api. The revision range origin/main..feature-api means commits reachable from feature-api that are not reachable from origin/main. The --no-merges option removes merge commits. The --oneline option produces one abbreviated commit hash and subject per line. The result is written in the same newest-first order shown in the diagram.

The shared history is A -> B -> C. The main side continues to D. The feature side contains c3d4e5f Add API validation and then d4e5f6a Fix API timeout. The merge commit M has both histories as parents, and feature-api points to M. The revision range removes commits already reachable from origin/main, and --no-merges removes M. The file therefore contains d4e5f6a Fix API timeout followed by c3d4e5f Add API validation.

I create a temporary file in the same directory as /home/interview/unique-commits.txt. Git writes its complete result to that temporary file. A cleanup trap removes the temporary file if the script fails or is interrupted. If Git succeeds, mv renames the temporary file to the final path. Because the temporary file and destination are in the same directory and filesystem, the rename is the atomic replacement step used by this solution.

After the successful rename, I disable the temporary-file cleanup trap because the temporary pathname no longer exists. I count the lines in the final file and print the count with the output path. If there are no matching commits, Git produces no lines, so the final file is empty and the count is zero. The script exits 0 on success. It only reads Git history, so the repository, refs, index, and worktree do not change. If the refs stay unchanged, repeated runs produce the same result.

The revision walk is O(V + E) over the commit graph Git actually traverses, where V is the traversed commits and E is the traversed parent relationships. Writing and counting the emitted result is O(k), where k is the number of output commits. Temporary and output storage is O(k). Important cases are an empty difference, missing repository, missing required refs, another Git or I/O failure, and repeated execution with unchanged refs.

The key idea is to use Git's revision-set operation instead of manually comparing commit hashes. origin/main..feature-api selects commits reachable from feature-api but not from origin/main. --no-merges then excludes every merge commit. The central invariant is that the existing output is not replaced until validation and the complete Git log operation have succeeded. The script performs all validation before creating or publishing the final output, uses only local refs, and never modifies repository state.

Let V be the number of commits Git traverses and E be the parent links it examines. The revision walk is O(V + E). Let k be the number of commits written to the result file. Writing and counting those lines is O(k). The temporary file and final output together represent O(k) generated output storage. The total work should not be described as only O(k), because Git may need to inspect more commits than it finally prints.

The required implementation is Bash, matching both the question and the approved diagram. The script defines the fixed repository and output paths and takes no arguments. It checks whether the repository path exists, enters it, and verifies Git metadata. It then validates refs/heads/feature-api and refs/remotes/origin/main, mapping an absent required ref to exit 2 and other Git errors to exit 1. Next it creates a temporary file in the output directory and installs a cleanup trap. The Git log command writes the unique non-merge commits into that temporary file. A successful same-directory mv publishes the result atomically. The script disables cleanup after the move, counts the output lines, logs the count, and exits 0. After saving the script as /home/interview/save_unique_commits.sh, run chmod +x /home/interview/save_unique_commits.sh once to satisfy the executable-file requirement.

A common mistake is running git fetch, even though this task requires only the existing local refs. Reversing the range to feature-api..origin/main selects the wrong commits. Forgetting --no-merges allows merge commits into the file. Writing directly to /home/interview/unique-commits.txt can replace a good previous result before the operation is complete. Another mistake is treating every git show-ref error as a missing ref instead of separating an absent ref from another Git failure. It is also incorrect to describe the total runtime as O(k) when Git may traverse more history than it emits.

Explain the solution as three safety boundaries: validate all required local state first, generate the exact revision difference into a temporary file, and publish it only with the final atomic rename. Then mention the exit-code split and the no-fetch rule.

I would read the three required log files once in frontend, API, then database order. I would validate every nonblank record, keep only exact request ID matches, and keep the parsed timestamp, file order, and line number as separate sort metadata. Then I would sort the matches and atomically replace the output file. The time is O(N + M log M), where M is the number of matches. Auxiliary space is O(M), plus the memory needed to serialize the output.

The script receives one request ID and looks through three fixed log files. Each nonblank line must describe one valid record with a timestamp and request ID. The script checks every record, keeps only records whose request ID matches exactly, and does not change any fields. Matching records are put in time order. If times are equal, frontend comes before API, then database, then the original line number decides. Only after all input succeeds does the script safely replace the result file. Any required input problem stops the result from being published.

1. Should an empty string be rejected as the request ID? The stated contract says yes.
2. Should blank log lines be ignored? Yes. The diagram ignores blank lines.
3. Should malformed nonmatching records still fail the run? Yes. Every nonblank record is validated before filtering.
4. Should an existing output file remain unchanged when validation fails? Yes. Publication happens only after all input succeeds.

The command is python3 /home/interview/trace_request.py REQUEST_ID. The script reads exactly /home/interview/frontend.log, /home/interview/api.log, and /home/interview/database.log. It writes one JSON array to /home/interview/request_trace.json. No matches means []. The three input files are never modified.

I first check that there is exactly one non-empty request ID argument. Then I open each required file once in frontend, API, database order. Blank lines are skipped. Every nonblank line must be valid JSON and must contain a JSON object. Its timestamp and request_id fields must both be strings. The timestamp must be valid RFC 3339. A wrong argument count, missing input file, malformed record, bad timestamp, or invalid required field exits with code 2. An unexpected I/O failure exits with code 1. There are no retries and no network operations.

For every valid record, I compare record["request_id"] with the requested ID using exact string equality. If it matches, I keep the original JSON object unchanged. I also keep separate metadata containing the parsed timestamp, file order, and original line number. This metadata is used only for sorting and is never added to the output object. Duplicate matching records are retained.

The frontend example is {"timestamp":"2026-02-13T10:15:30.123Z","service":"frontend","request_id":"req_abc123","message":"Request received","duration_ms":142}. The API example is {"timestamp":"2026-02-13T10:15:30.245Z","service":"api","request_id":"req_abc123","message":"Processing request"}. Both match req_abc123. The database example in the diagram has a different request ID, so it is not selected. The frontend timestamp is earlier, so the frontend object appears first and the API object second. Their original fields remain unchanged.

The sort key is (parsed timestamp, file order, line number). File order is frontend first, API second, database third. The line number breaks a remaining tie between records from the same file. After all three files have been read and validated successfully, I create a temporary file in the output directory. I write the complete array there, flush it, close it, and atomically replace /home/interview/request_trace.json. A validation or earlier read failure therefore cannot publish a partial result.

Every nonblank record is validated before filtering, so an invalid record cannot be silently skipped. Only exact request ID matches enter the result. The three-part sort key exactly implements the required ordering. The original JSON object is stored separately from its sort metadata, so no fields are added or removed. With N total records and M matching records, reading and validation take O(N), while sorting takes O(M log M). Total time is O(N + M log M). Auxiliary space is O(M), plus output serialization. Important cases are no matches, duplicate matches, equal timestamps, blank lines, and rerunning the script with the same unchanged inputs.

The key idea is to separate validation, matching, ordering metadata, and publication. Every nonblank record is fully validated before the request ID check. A matching record is stored unchanged together with three separate sort values: its parsed timestamp, the fixed file order, and its original line number. The central invariant is that every item in the match list is a fully validated exact request ID match and its original JSON object has not been modified. Sorting by those three values gives the required deterministic order. The final file is replaced only after all reads, validation, filtering, and sorting succeed.

The program first validates the command line. It requires exactly one non-empty request ID. It then processes the three fixed files in frontend, API, database order because that order is also a timestamp tie-breaker.

Each file is opened once. The program skips blank lines. For every nonblank line, it parses strict JSON, requires a JSON object, checks that timestamp and request_id are strings, and parses the RFC 3339 timestamp. Validation happens before filtering, so even a malformed record with a different request ID still causes exit code 2.

When a record's request ID matches exactly, the program stores a tuple containing its parsed timestamp, file order, line number, and untouched JSON object. Duplicate records are not removed. After all three files succeed, the tuples are sorted using timestamp first, then file order, then line number. Only the original JSON objects are copied into the result array.

For publication, the program creates a temporary file in the same directory as the final output. It writes the complete JSON array, flushes and syncs the file, closes it, and calls os.replace. This keeps the previous final output unchanged until the new result is complete. A missing required input file or validation error returns 2. An unexpected read, write, or replace I/O error returns 1. Success prints the number of files, total records, matching records, and output path, then returns 0.

A common mistake is filtering by request ID before validating the whole record. That can silently ignore malformed nonmatching lines, which violates the contract. Another mistake is adding file_order or line_number fields to the output objects instead of keeping that metadata separately. Candidates may also forget the exact tie-break order, accidentally remove duplicate matches, read a file more than once, retry after a failure, or write directly to the final path and expose a partial result. A missing required input file must return 2, while an unexpected I/O failure returns 1.

Explain the solution around four guarantees: validate every nonblank record, keep matching objects unchanged, sort with the exact three-part key, and publish only with an atomic replacement after every input operation succeeds.

I would safely load both YAML files, reject duplicate keys and invalid top-level values, and deep-merge them without changing either parsed input. When both values are mappings, I merge them recursively. Otherwise, the override replaces the base value completely, including lists and nulls. I then validate the merged database mapping and atomically replace the JSON output. For normal tree-shaped configuration data, the merge and serialization take O(N) time and use O(N) auxiliary space.

This task combines two YAML configuration files. The second file changes values from the first file. Nested groups must stay merged instead of being replaced as a whole. Lists, simple values, and null values are replaced completely. The original loaded data must stay unchanged. After merging, the program keeps only the database part and writes it as readable JSON. Bad input must not damage an older output file. A successful run publishes the completed file with one atomic replacement.

1. Should duplicate keys introduced through YAML merge-key features also be rejected, or only duplicate explicit keys in the same mapping?
2. Should the success summary be written to standard error or standard output?
3. For deterministic JSON, should stable input mapping order be preserved, as shown in the diagram, or should keys be sorted canonically?

The script expects exactly two paths after the script name: BASE_YAML and OVERRIDES_YAML. It opens both files as UTF-8 and uses a loader derived from yaml.SafeLoader. Safe loading rejects unsafe custom tags. A custom mapping constructor rejects duplicate explicit keys. Each loaded root must be a mapping. Missing arguments, missing files, malformed YAML, unsafe tags, duplicate keys, and non-mapping roots return exit code 2.

The merge function creates a new dictionary. It starts with the base keys in their existing order. For a key that exists in both mappings, it checks both values. If both values are mappings, it recursively creates another merged dictionary. Otherwise, it copies the override value into the result. Lists, scalar values, and None therefore replace the base value completely. Base-only and override-only values are also copied, so neither parsed input is modified.

After the complete merge, the script looks for the key database. That value must exist and must be a mapping. If it is missing or has another type, the script returns exit code 2 before any final output replacement happens. This keeps an existing /home/interview/database_config.json unchanged on validation failures.

The base contains database.primary.host = dev-db, database.primary.port = 5432, and database.max_connections = 20. The override contains database.primary.host = prod-db-primary.example.com and database.max_connections = 50. The two database values are mappings, so they merge. The two primary values are also mappings, so they merge. The host changes to prod-db-primary.example.com, the port remains 5432, and max_connections changes to 50. The final database data is {"primary":{"host":"prod-db-primary.example.com","port":5432},"max_connections":50}.

The script serializes only the validated database mapping as pretty UTF-8 JSON. It keeps stable mapping order with sort_keys=False, uses indent=2, and uses ensure_ascii=False. It writes to a temporary file in the same directory as the final output. It flushes Python's buffer and calls os.fsync() on the temporary file. It then calls os.replace() to atomically publish the completed file at /home/interview/database_config.json. Readers therefore see either the previous complete file or the new complete file, not a partially written file.

Input and data errors use exit code 2 and do not replace an existing output. Unexpected read, temporary-file, flush, fsync, or replacement failures use exit code 1. On success, the script logs a short summary containing the number of top-level database keys and the output path, then exits 0. There is no network work, timeout, or retry. With unchanged inputs, the same merge order and JSON formatting produce the same output bytes.

The key idea is a non-mutating recursive deep merge. The central invariant is: for every key already placed in the result, the result contains a copied base value when no override exists; if an override exists and both values are mappings, the result contains their recursive merge; otherwise the result contains a copy of the override value. The function never writes into either parsed YAML mapping. After the merge, the database value is validated before publication. A temporary file followed by os.replace() provides the atomic publish step shown in the diagram.

The program defines StrictSafeLoader as a subclass of yaml.SafeLoader. Its mapping constructor checks explicit keys and raises a YAML error if the same explicit key appears twice in one mapping. load_yaml_mapping() opens one file, parses it with that safe loader, and verifies that the root is a mapping. deep_merge() builds a fresh dictionary. It recursively merges a value only when both the base and override values are mappings. Every other override value replaces the base value completely and is deep-copied.

write_database_json_atomically() creates a temporary file in /home/interview, writes only the database mapping as pretty UTF-8 JSON, flushes it, calls os.fsync(), and publishes it with os.replace(). main() checks the exact two-argument CLI contract, loads both YAML files, performs the merge, validates the merged database mapping, and writes the file. Required input and data errors return 2. Unexpected OSError failures return 1. Success logs a summary and returns 0.

Common mistakes are using a shallow dict.update(), which would lose primary.port; recursively merging lists even though lists must be replaced; mutating the parsed base mapping in place; allowing duplicate explicit YAML keys silently; using an unsafe YAML loader; replacing the output before all validation succeeds; and writing directly to the final path instead of using a temporary file followed by os.replace(). Another mistake is classifying every OSError as exit code 2. A missing input file is a required validation error, while unexpected I/O failures use exit code 1.

Explain the solution as three guarantees: validate safely first, perform a non-mutating recursive merge second, and publish atomically last. Then use primary.host, primary.port, and max_connections from the supplied example to show exactly why nested mappings merge while ordinary values are replaced.

I would validate exactly one positive decimal PID and confirm that /proc/<pid> exists. Then I would read /proc/<pid>/cgroup and take the last path component ending in .service, so I never guess from the executable name. After resolving the unit, I print the PID and service, then run full systemctl status and the latest 20 journalctl entries. The script makes a constant number of read-only system queries and uses O(1) extra script space besides command output.

The utility receives one process ID. That PID must be a positive decimal number and must exist when validation starts. The script finds the systemd service that owns the process by reading the process cgroup information. It never guesses from the executable name. After finding the service, it prints the PID, service name, full service status, and no more than the latest 20 journal entries. Bad input, a missing PID, or no managing service returns exit code 2. A status or log command failure after resolving the service returns 1. Full success returns 0.

1. If the PID exists but its cgroup path contains no .service component, should I treat it as not managed by a service and exit 2?
2. If systemctl status fails, should I still try journalctl, and vice versa?
3. Should the utility remain completely read-only with no restart, signal, network call, retry, or timeout?

The script requires exactly one argument. The argument must match a positive decimal PID, so zero, negative values, text, and extra arguments are rejected. It then checks that /proc/<pid> exists. This verifies that the process exists when validation begins. If either validation check fails, the script writes an error to stderr and exits with code 2.

For the diagram example, the PID is 4567, so the process directory is /proc/4567.

The script reads /proc/4567/cgroup. It takes the cgroup path field, splits that path on /, and looks for path components ending in .service. The last matching component becomes the unit name.

For PID 4567, the cgroup path contains /system.slice/nginx.service. The resolved unit is therefore nginx.service.

This is the central correctness rule. The service name comes directly from the PID's cgroup information. The script never guesses from the executable name. If no .service component is found, it exits 2 without printing a guessed report.

After resolving the unit, the script prints: PID: 4567 SERVICE: nginx.service

These two lines identify the exact process and service used for the rest of the report.

The script prints ---- STATUS ---- and runs systemctl status "nginx.service" --no-pager. Its normal output goes directly to stdout, so the full status output is preserved.

Next, the script prints ---- LOGS ---- and runs journalctl -u "nginx.service" -n 20 --no-pager. This returns no more than the latest 20 journal entries for the resolved unit.

The two retrieval commands are handled independently. If status fails, the script records that failure but still attempts the logs command. If logs fail, any status output already printed remains available. Each failed command is written to stderr.

Exit code 0 means the unit was resolved and both retrieval commands succeeded. Exit code 1 means the unit was resolved but at least one of the status or log commands returned failure. Exit code 2 means invalid arguments, a PID that was missing during validation, or no managing .service unit.

The script does not restart, stop, kill, or otherwise signal the process. It makes no network call and uses no retries or timeouts.

The key invariant is that UNIT is taken only from a .service path component found in /proc/<pid>/cgroup. Every later command uses that same resolved unit. This keeps the report consistent and prevents executable-name guessing.

The script performs a constant number of read-only system operations for one PID. Its own extra state is only a small set of scalar variables and failure flags, so auxiliary script space is O(1) besides command output. Important cases include invalid input, a missing PID, no .service component, one retrieval command failing, both retrieval commands failing, and the process disappearing after the initial validation check.

The key insight is to use the PID's cgroup path as the source of truth for systemd ownership. First validate exactly one positive decimal PID and confirm /proc/<pid> exists. Then read /proc/<pid>/cgroup, split the cgroup paths into /-separated components, and select the last component ending in .service. The central invariant is that the reported service must come from that PID's cgroup data. It is never inferred from the executable name. After the unit is resolved, the same unit is used for both systemctl status and journalctl, and failures from those two commands are tracked independently.

The script makes a constant number of read-only system operations for one PID: it checks /proc/<pid>, reads the PID's cgroup information, runs one systemctl status command, and runs one journalctl command. The cgroup pipeline streams its input and the script stores only small scalar values such as the PID, unit name, and two failure flags. Auxiliary script space is O(1) besides the output produced by the system commands. The amount of displayed status and journal text is output data, not extra algorithm state.

Because the original task explicitly requires an executable Bash utility, the final implementation is Bash and matches the diagram. The script starts with set -u, validates exactly one positive decimal PID, and verifies that /proc/$PID exists. It then reads /proc/$PID/cgroup with a streaming pipeline. awk selects the cgroup path field, tr splits the path into components, grep keeps components ending in .service, and tail -n 1 selects the final matching service component.

If no unit is found, the script exits 2 before producing a guessed report. After a unit is found, it prints PID and SERVICE. It then prints the STATUS header and runs systemctl status "$UNIT" --no-pager. It separately prints the LOGS header and runs journalctl -u "$UNIT" -n 20 --no-pager. Each command writes its normal output directly to stdout. A nonzero command result sets its failure flag and logs the exact failed command to stderr. Both retrieval commands are attempted. The script exits 0 only when both succeed, otherwise it exits 1.

One mistake is guessing the service from the executable name instead of reading /proc/<pid>/cgroup. Another is accepting PID 0 even though the input must be a positive decimal PID. A candidate may also exit immediately after a failed systemctl status command and never try to collect logs. Another mistake is returning exit code 2 for a status or log failure after the unit has already been identified. It is also incorrect to restart, stop, kill, or signal the process because the utility must remain read-only.

Lead with the ownership lookup. Explain that /proc/<pid>/cgroup is the source of truth and that you only accept an actual path component ending in .service. Then explain why status and log collection are independent and finish with the meanings of exit codes 0, 1, and 2.

At a high level, replication keeps several copies of the same data so one node failure does not stop the service. The challenge is keeping those copies useful and reasonably up to date. I would explain it through the write path, read path, and failure-recovery path. Writes go to a primary and then to secondary replicas. Reads can use a healthy replica. The benefit is higher availability and durability. The downside is lag, duplicate or conflicting updates, recovery complexity, and higher cost.

The goal is to keep the same data on several nodes so one failed node does not stop the service. The hard part is keeping those copies close enough to each other while the system keeps serving requests. A failed copy must also be noticed and safely replaced or brought back. The diagram organizes the answer into three main parts: how writes reach all copies, how reads choose a healthy copy, and how failures are detected and repaired. It also shows the extra delay, complexity, and cost that replication creates.

1. How much delay between replicas is acceptable for reads?
2. Must a write wait for more than one replica before success is returned?
3. Can normal reads use secondary replicas, or must important reads use the primary?
4. How quickly should the service recover after a replica or primary fails?

I would place replicas in independent failure areas when possible. The diagram uses separate nodes or availability zones. This matters because copies on the same failed machine would not protect us.

Requests first pass through the Entry Point & Controls. It handles authentication, authorization, validation, rate limiting, and a Request ID used as an idempotency key. That key helps recognize the same write request when a retry happens, which reduces accidental duplicate writes.

For a write, the Service Layer sends the change to Replica 1, the Primary. The primary then replicates the update to Replica 2 and Replica 3, which are Secondary replicas. Replication can be synchronous or asynchronous.

The write is acknowledged using the configured policy. The system may accept the primary commit, or it may wait for a quorum. A quorum means enough replicas have accepted the write before success is returned. Waiting for more replicas can reduce data-loss risk, but it can make writes slower.

For reads, the Service Layer uses the Choose Replica step. Strong reads can use the Primary. Other reads may use the nearest or least-loaded healthy replica. A low-latency read may also accept a slightly older value.

That older value happens because a Secondary can be at version vN or still be lagging. The Primary is shown at the current version. This small delay is the main consistency risk when reads use replicas.

The Failure Detection & Recovery flow starts with health checks or heartbeats between members or a coordinator. After a timeout or threshold, the Decision step can mark a node unhealthy.

The Act step may promote a healthy Secondary when the failed node was the leader. It can also reconfigure membership and start repair. A Recovering / Replacement Replica copies missed data from a healthy replica until it catches up. Coordination / Consensus supports leader election and membership when the design requires it.

Observability supports this work with logs, metrics, traces, and alerts. These signals help operators notice failures and understand recovery behavior.

Replication improves availability because healthy replicas can continue serving data after a node failure. It also improves durability because several nodes hold copies.

The downside is more complexity. Replicas can lag and return stale data. Concurrent updates can conflict. Retries can create duplicate writes when duplicate protection is missing. Failure detection can also make mistakes or take time. Stronger consistency can reduce availability during network partitions. More replicas also increase storage, network traffic, monitoring work, and infrastructure cost.

The benefit is better availability and durability. One failed node does not have to stop the whole service, and another healthy replica can take over. The downside is that copies may not be updated at exactly the same moment. Waiting for more replicas makes writes safer, but it can add delay and reduce availability during network problems. Reading from a nearby Secondary can be faster, but that copy may be behind. Replication also adds more machines, storage, network traffic, monitoring, leader changes, repair work, and failure cases. We accept that extra cost when surviving node failures matters.