DEV Community: Lucas Queiroz

Software Engineer Interviews - #3 OEIS CLI

Lucas Queiroz — Sat, 23 Nov 2024 09:10:48 +0000

Introduction

This is the third post of the Software Engineer Interviews series. I have brought a challenge I did a few years ago, and actually got the position - other tech interviews were involved, such as a past experience screening.

If you've missed the previous posts on this series, you can find them here.

The Challenge

This challenge was also a take-home coding task, where I had to develop a CLI program that would query the OEIS (On-Line Encyclopedia of Integer Sequences) and return the total number of results, and the name of the first five sequences returned by the query.

Thankfully, the OEIS query system includes a JSON output format, so you can get the results by calling the url and passing the sequence as a query string.

Example input and output:

oeis 1 1 2 3 5 7

Found 1096 results. Showing first five:
1. The prime numbers.
2. a(n) is the number of partitions of n (the partition numbers).
3. Prime numbers at the beginning of the 20th century (today 1 is no longer regarded as a prime).
4. Palindromic primes: prime numbers whose decimal expansion is a palindrome.
5. a(n) = floor(3^n / 2^n).

Note: this result is outdated!

Solving the Challenge

The plan to solve this challenge is the following:

Start with a Python file that will be the CLI entrypoint
- It should receive a list of numbers separated by spaces as argument
Create a client file that will be responsible to fetch data from the OEIS query system
A formatter that will take care of returning the output formatted for the console

Since this is a coding challenge, I will be using Poetry to help me create the structure of the project, and to facilitate anyone running it. You can check how to install and use Poetry on their website.

I’ll start by creating the package with:

poetry new oeis

This will create a folder called oeis, which will contain the Poetry’s configuration file, a test folder, and a folder also called oeis, which will be the root of our project.

I will also add an optional package, called Click, which helps building CLI tools. This is not required, and can be replaced by other native tools from Python, although less elegant.

Inside the project’s folder, run:

poetry add click

This will add click as a dependency to our project.

Now we can move to our entrypoint file. If you open the folder oeis/oeis, you will see there’s already an __init__.py file. Let’s update it to import Click, and a main function to be called with the command:

# oeis/oeis/__init__.py

import click


@click.command()
def oeis():
    pass


if __name__ == "__main__":
    oeis()

This is the starting point to our CLI. See the @click.command? This is a wrapper from click, which will help us define oeis as a command.

Now, remember we need to receive the sequence of numbers, separated by a space? We need to add this as an argument. Click has an option for that:

# oeis/oeis/__init__.py

import click


@click.command()
@click.argument("sequence", nargs=-1)
def oeis(sequence: tuple[str]):
    print(sequence)


if __name__ == "__main__":
    oeis()

This will add an argument called sequence, and the nargs=-1 option tells click it will be separated by spaces. I added a print so we can test the argument is being passed correctly.

To tell Poetry that we have a command, we need to open pyproject.toml and add the following lines:

# oeis/pyproject.toml

[tool.poetry.scripts]
oeis = "oeis:oeis"

This is adding a script called oeis, which calls the oeis function on the oeis module. Now, we run:

poetry install

which will let us call the script. Let’s try it:

❯ poetry run oeis 1 2 3 4 5
('1', '2', '3', '4', '5')

Perfect, we have the command and the arguments being parsed as we expected! Let's move on to the client. Under the oeis/oeis folder, create a folder called clients, a file called __init__.py and a file called oeis_client.py.

If we expected to have other clients in this project, we could develop a base client class, but since we will only have this single one, this could be considered over-engineering. In the OEIS client class, we should have a base URL, which is the URL without the paths, and that we will use to query it:

# oeis/oeis/clients/oeis_client.py

import requests

from urllib.parse import urlencode


class OEISClient:
    def __init__(self) -> None:
        self.base_url = "https://oeis.org/"

    def query_results(self, sequence: tuple[str]) -> list:
        url_params = self.build_url_params(sequence)
        full_url = self.base_url + "search?" + url_params

        response = requests.get(full_url)
        response.raise_for_status()
        return response.json()

    def build_url_params(self, sequence: tuple[str]) -> str:
        sequence_str = ",".join(sequence)
        params = {"q": sequence_str, "fmt": "json"}
        return urlencode(params)

As you can see, we are importing the requests package. We need to add it to Poetry before we can use it:

poetry add requests

Now, the client has a base url which does not change. Let's dive into the other methods:

build_url_params
- Receives the sequence passed as argument from the CLI, and transforms it into a string of numbers separated by a comma
- Builds a dict with the params, the q being the query we will run, and fmt being the output format expected
- Lastly, we return the URL encoded version of the params, which is a nice way to ensure our string is compatible with URLs
query_results
- Receives the sequence passed as argument from the CLI, builds the url encoded params through the build_url_params method
- Builds the full URL which will be used to query the data
- Proceeds with the request to the URL built, and raises for any HTTP status that we didn’t expect
- Returns the JSON data

We also need to update our main file, to call this method:

# oeis/oeis/__init__.py

import click

from oeis.clients.oeis_client import OEISClient


OEIS_CLIENT = OEISClient()


@click.command()
@click.argument("sequence", nargs=-1)
def oeis(sequence: tuple[str]):
    data = OEIS_CLIENT.query_results(sequence)
    print(data)


if __name__ == "__main__":
    oeis()

Here we are now building a client instance, outside the method, so it doesn’t create an instance every time the command is called, and calling it inside the command.

Running this results in a very, very long response, since the OEIS has thousands of entries. As we only need to know the total size and the top five entries, we can do the following:

# oeis/oeis/__init__.py

import click

from oeis.clients.oeis_client import OEISClient


OEIS_CLIENT = OEISClient()


@click.command()
@click.argument("sequence", nargs=-1)
def oeis(sequence: tuple[str]):
    data = OEIS_CLIENT.query_results(sequence)
    size = len(data)
    top_five = data[:5]
    print(size)
    print(top_five)


if __name__ == "__main__":
    oeis()

Running this is already way better than before. We now print the total size, and the top five (if they exist) entries.

But we also don’t need all of that. Let's build a formatter to correctly format our output. Create a folder called formatters, which will have a __init__.py file and a oeis_formatter.py file.

# oeis/oeis/formatters/oeis_formatter.py

def format_output(query_result: list) -> str:
    size = len(query_result)
    top_five = query_result[:5]
    top_five_list = [f"{i+1}. {entry["name"]}" for i, entry in enumerate(top_five)]
    top_five_str = "\n".join(top_five_list)

    first_line = f"Found {size} results. Showing the first {len(top_five)}:\n"

    return first_line + top_five_str

This file is basically formatting the top five results into what we want for the output. Let’s use it in our main file:

# oeis/oeis/__init__.py

import click

from oeis.clients.oeis_client import OEISClient
from oeis.formatters import oeis_formatter


OEIS_CLIENT = OEISClient()


@click.command()
@click.argument("sequence", nargs=-1)
def oeis(sequence: tuple[str]):
    data = OEIS_CLIENT.query_results(sequence)
    output = oeis_formatter.format_output(data)
    print(output)


if __name__ == "__main__":
    oeis()

If you run this code, you will get this now:

Found 10 results. Showing the first 5:
1. a(n) is the number of partitions of n (the partition numbers).
2. a(n) = floor(3^n / 2^n).
3. Partition triangle A008284 read from right to left.
4. Number of n-stacks with strictly receding walls, or the number of Type A partitions of n in the sense of Auluck (1951).
5. Number of partitions of n into prime power parts (1 included); number of nonisomorphic Abelian subgroups of symmetric group S_n.

It is now returning with the format we expect, but notice that it says it found 10 results. This is wrong, if you search on the OEIS website you will see there are way more results. Unfortunately, there was an update to OEIS API and the result no longer returns a count with the number of results. This count still shows up on the text formatted output, though. We can use it to know how many results there are.

To do this, we can change the URL to use the fmt=text, and a regex to find the value we want. Let’s update the client code to fetch the text data, and the formatter to use this data so we can output it.

# oeis/oeis/clients/oeis_client.py

import re
import requests

from urllib.parse import urlencode


class OEISClient:
    def __init__(self) -> None:
        self.base_url = "https://oeis.org/"
        self.count_regex = re.compile(r"Showing .* of (\d*)")

    def query_results(self, sequence: tuple[str]) -> list:
        url_params = self.build_url_params(sequence, fmt="json")
        full_url = self.base_url + "search?" + url_params

        response = requests.get(full_url)
        response.raise_for_status()
        return response.json()

    def get_count(self, sequence: tuple[str]) -> str:
        url_params = self.build_url_params(sequence, fmt="text")
        full_url = self.base_url + "search?" + url_params

        response = requests.get(full_url)
        response.raise_for_status()
        return self.get_response_count(response.text)

    def build_url_params(self, sequence: tuple[str], fmt: str) -> str:
        sequence_str = ",".join(sequence)
        params = {"q": sequence_str, "fmt": fmt}
        return urlencode(params)

    def get_response_count(self, response_text: str) -> str:
        match = self.count_regex.search(response_text)

        if not match:
            raise Exception("Count not found!")

        return match.group(1)

As you can see, we added two new methods:

get_count
- Will build the params for the text API, and pass it to the method which will use regex to find the number we are searching for
get_response_count
- Will use the regex built in the class’ init to perform a search and get the first group

# oeis/oeis/formatters/oeis_formatter.py

def format_output(query_result: list, count: str) -> str:
    top_five = query_result[:5]
    top_five_list = [f"{i+1}. {entry["name"]}" for i, entry in enumerate(top_five)]
    top_five_str = "\n".join(top_five_list)

    first_line = f"Found {count} results. Showing the first {len(top_five)}:\n"

    return first_line + top_five_str

In this file, we only added a new param for the method, and used it instead of the length of the query result.

# oeis/oeis/__init__.py

import click

from oeis.clients.oeis_client import OEISClient
from oeis.formatters import oeis_formatter


OEIS_CLIENT = OEISClient()


@click.command()
@click.argument("sequence", nargs=-1)
def oeis(sequence: tuple[str]):
    data = OEIS_CLIENT.query_results(sequence)
    count = OEIS_CLIENT.get_count(sequence)
    output = oeis_formatter.format_output(data, count)
    print(output)


if __name__ == "__main__":
    oeis()

Here we are just calling the new method on the client, and passing the information to the formatter. Running it again results in the output we were expecting:

❯ poetry run oeis 1 2 3 4 5
Found 7821 results. Showing the first 5:
1. The positive integers. Also called the natural numbers, the whole numbers or the counting numbers, but these terms are ambiguous.
2. Digital sum (i.e., sum of digits) of n; also called digsum(n).
3. Powers of primes. Alternatively, 1 and the prime powers (p^k, p prime, k >= 1).
4. The nonnegative integers.
5. Palindromes in base 10.

The code is basically ready. But for a real challenge, remember to use Git when possible, do small commits, and of course, add unit tests, code formatting libs, type checkers, and whatever else you feel you will need.

Good luck!

Software Engineer Interviews - #2 Webhook Log Parser

Lucas Queiroz — Fri, 15 Nov 2024 02:41:51 +0000

Disclaimer

I initially posted this article on Substack, but as it doesn't have a proper code formatting tool yet, I decided to move it here.

Introduction

This is the second post of the Software Engineer Interview series. In this first post, I have shared how I plan to do the series, some general tips and study guide for interviews.

In this second post, I will start with a challenge that I did a few years ago, and I now consider it simple. I do not remember exactly how I completed the challenge at the time, but being a very junior developer, I wanted to “show knowledge” and did it in multiple languages - something I wouldn’t do now, I would focus on the quality of the code.

The Challenge

The challenge consists of parsing an HTTP log file, and retrieving the most requested URLs and statuses. It will be a CLI application, and the output is a list with the top 10 URLs and the top 10 response statuses, followed by the number of responses. Example:

Top 10 URLs:
- https://google.com - 100

Top 10 statuses:
- 200 - 23

The log structure is the following:

One log per line
Each line contains multiple attributes, in the format key=value, each pair separated by a space
Keys:
- level
- response_body
- request_to
- response_headers
- response_status

You can download the log file here.

Solving the Challenge

The first step here is to parse the file, either by reading every line or going through a stream. In Python, which is what I will be using here to solve this challenge, you can iterate through the file lines, without the need to save all the lines in memory, not only saving resources but increasing the performance of the project.

Let's assume the log is saved in the same folder as your Python code, and the log’s file name is log.txt. To parse it in a stream, without saving all the lines in memory, we can do the following:

# solution.py

with open("log.txt", "r") as log:
    for line in log:
        print(line)

You can run this in your terminal with:

python3 solution.py

If you run this code, you will see that each line is printed with a newline character at the end. We can fix this by calling .strip().

# solution.py

with open("log.txt", "r") as log:
    for line in log:
        print(line.strip())

Now, to the actual parsing of the line data and counting instances, there are multiple ways of doing this. The one I find easier and with a better performance is to use regex to parse the line, and Python’s Counter to count the elements. Other ways to do this would be:

Splitting the line
- You can split the line by spaces, and then have if checks to see if the key is what you need (request_to, response_status), then replace the key name and equal sign to an empty string and get the value.
Counting with a dictionary
- You can have a dictionary where they key is the URL or the status code, and the value being the number of times it appeared.

Let’s start by parsing the line with regex, to obtain the data we need from the line (the URL and the response status).

You need to import the re package from Python, and create a regex pattern. The pattern will be grouping the values we need, so we can refer back to them later. Since the lines are formatted in a way where the value will start and end with quotes (“), we can have a simple regex to group them:

.*request_to="(.*)".*response_status="(.*)".*

Explanation:

.* will match any character, any number of times
request_to=” will match itself
(.*) will match any character after the previous token, any number of times, and group it
“ will match a quote, ending the value
.* again to ignore anything between the tokens
response_status=” will match itself
(.*) will again match anything inside the quotes for the value
“ will match a quote, ending the value
.* will match the end of the string, even if it has nothing after the response status

Let's update the code to match the line and get the groups:

# solution.py

import re


regex = re.compile(r".*request_to=\"(.*)\".*response_status=\"(.*)\".*")


def process_line(line: str) -> None:
    match = regex.search(line)
    if match:
        request_to = match.group(1)
        response_status = match.group(2)


with open("log.txt", "r") as log:
    for line in log:
        process_line(line)

As you can see, there were a lot of changes to the code. Let’s break them down:

import re
- This imports the re package from Python so we can use the regex functionality
regex = re.compile(r".request_to=\"(.)\".response_status=\"(.)\".*")
- This builds a variable called regex, which uses the regex we built before
def process_line
- This is a new method I added so we can separate the concerns of processing the line from the line reading
match = regex.search(line)
- This will call the search function on the regex we compiled, and tell it to search on the line we received in the method’s parameter
if match:
- This is checking if the match was successful. If the line doesn’t match with our regex, it will not enter the condition
The next two lines will get the values from the regex groups we built before and set them to variables with appropriate names

Now, we need to count the request_to and response_status, and for this we can use the Counter.

Since strings can be parsed as lists in Python, and Counter expects a list, if we just pass the string directly, it will count the characters in the string, and not the entire string, so we need to wrap the value in a list before passing it to Counter. This is the updated code with the Counter part:

# solution.py

import re
from collections import Counter


regex = re.compile(r".*request_to=\"(.*)\".*response_status=\"(.*)\".*")
request_to_counter = Counter()
response_status_counter = Counter()


def process_line(line: str) -> None:
    match = regex.search(line)
    if match:
        request_to = match.group(1)
        response_status = match.group(2)
        request_to_counter.update([request_to])
        response_status_counter.update([response_status])


with open("log.txt", "r") as log:
    for line in log:
        process_line(line)

Again, here are the main changes:

from collections import Counter
- This is importing the Counter class into our code
request_to_counter = Counter()
- This is creating a new instance of the Counter and assigning it to the request_to_counter variable
response_status_counter = Counter()
- Same as above
request_to_counter.update([request_to])
- This is telling the request_to_counter to add one more item, and wrapping the value in a list, as explained above
response_status_counter.update([response_status])
- Same as above

If we print out the counters at the end of the file, this is what we will receive as output:

Counter({'https://eagerhaystack.com': 750, 'https://surrealostrich.com.br': 734, 'https://grimpottery.net.br': 732, 'https://abandonedpluto.com': 731, 'https://easterncobra.com.br': 730, 'https://solidstreet.net': 725, 'https://notoriouslonesome.com': 724, 'https://solidwindshield.net.br': 713, 'https://intensecloud.us': 712, 'https://grotesquemoon.de': 706, 'https://severeleather.com': 693, 'https://endlessiron.com.br': 688, 'https://woodenoyster.com.br': 685, 'https://steepBoomerang.me': 677})

Counter({'404': 1474, '503': 1451, '400': 1440, '500': 1428, '200': 1417, '201': 1402, '204': 1388})

This means we already have the counting part done! We just need to get the top 10 from the counter, and format the output.

To get the top 10 from the counter, we can use the function most_common(int), which will output an ordered list of tuples, each tuple containing the key and the value. We can then use this to format the output:

# solution.py

import re
from collections import Counter


regex = re.compile(r".*request_to=\"(.*)\".*response_status=\"(.*)\".*")
request_to_counter = Counter()
response_status_counter = Counter()


def process_line(line: str) -> None:
    match = regex.search(line)
    if match:
        request_to = match.group(1)
        response_status = match.group(2)
        request_to_counter.update([request_to])
        response_status_counter.update([response_status])


with open("log.txt", "r") as log:
    for line in log:
        process_line(line)

top_ten_urls = request_to_counter.most_common(10)
top_ten_status_codes = response_status_counter.most_common(10)

print("Top 10 URLs:")
for url, count in top_ten_urls:
    print(f"{url} - {count}")


print("")
print("Top 10 status codes:")
for status_code, count in top_ten_status_codes:
    print(f"{status_code} - {count}")

Once again, there is a lot of changes in the code, here they are:

top_ten_urls = request_to_counter.most_common(10)
- This is using the function I mentioned previously, to retrieve the top 10 urls
top_ten_stauts_codes = response_status_counter.most_common(10)
- Same as above
for url, count in top_ten_urls:
- This is looping through each element in the top 10 urls. Since each element is a tuple with two elements, we can use the syntax first_var, second_var to retrieve both data at the same time with a nice variable name
for status_code, count in top_ten_status_codes:
- Same as above

The other lines are printing out strings

Basically, our logic is done. This is the output from running this file:

Top 10 URLs:
https://eagerhaystack.com - 750
https://surrealostrich.com.br - 734
https://grimpottery.net.br - 732
https://abandonedpluto.com - 731
https://easterncobra.com.br - 730
https://solidstreet.net - 725
https://notoriouslonesome.com - 724
https://solidwindshield.net.br - 713
https://intensecloud.us - 712
https://grotesquemoon.de - 706

Top 10 status codes:
404 - 1474
503 - 1451
400 - 1440
500 - 1428
200 - 1417
201 - 1402
204 - 1388

We can still improve the code though, by separating the logic to retrieve top 10 in different methods, and add a main method to the file.

# solution.py

import re
from collections import Counter


regex = re.compile(r".*request_to=\"(.*)\".*response_status=\"(.*)\".*")
request_to_counter = Counter()
response_status_counter = Counter()


def process_line(line: str) -> None:
    match = regex.search(line)
    if match:
        request_to = match.group(1)
        response_status = match.group(2)
        request_to_counter.update([request_to])
        response_status_counter.update([response_status])


def process_file() -> None:
    with open("log.txt", "r") as log:
        for line in log:
            process_line(line)


def print_top_ten_urls() -> None:
    top_ten_urls = request_to_counter.most_common(10)

    print("Top 10 URLs:")
    for url, count in top_ten_urls:
        print(f"{url} - {count}")


def print_top_ten_status_codes() -> None:
    top_ten_status_codes = response_status_counter.most_common(10)

    print("Top 10 status codes:")
    for status_code, count in top_ten_status_codes:
        print(f"{status_code} - {count}")


if __name__ == "__main__":
    process_file()
    print_top_ten_urls()
    print("")
    print_top_ten_status_codes()

This is basically just separating the code in methods, to improve readability and separating concerns. The last part, if __name__ == “__main__” tells Python this is the main method of the file, so if it is imported somewhere with import solution, it will run the main method.

What to Study

A good study guide for this challenge would be:

Regex
Python Counter

Other items you may want to study, which can help on a similar challenge, and could be faster to code in a live coding environment would be:

Python dicts
Sorting dicts with Python

I hope this helps you prepare for your next challenge!

Software Engineer Interviews - #1 Intro

Lucas Queiroz — Fri, 15 Nov 2024 02:28:25 +0000

Disclaimer

I initially posted this article on Substack, but as it doesn't have a proper code formatting tool yet, I decided to move it here.

Introduction

After 7 years working as a Software Engineer, I have done a lot of interviews. Most of them were introduction calls, technical introductions and past experience, and some live coding interviews, projects, software architecture screenings, and some hacker rank problems.

I wanted to share the knowledge acquired in this process, so that others can prepare for when their live coding interview comes, or just to understand how the interviews are.

The Series

Introduction
Webhook Log Parser
OEIS CLI
Coming soon

I will be sharing the content in the form of a series of posts, each one with a different challenge.

I plan to share my experience with:

Live coding interviews
Hacker rank/leet code challenges
Code projects
Software architecture screenings

I will not be sharing the name of the company of the challenge in the post, for obvious reasons. For the same obvious reasons, I will not be sharing the challenges from positions I am currently in the process, or have been in the recent past.

I will try my best to provide the thought process and the most efficient answers to the challenges, as well as what I did and my outcome for them.

Preparing for an Interview

If you landed here, it is likely that you are preparing yourself for a live coding interview, or a tech challenge. Here are some tips that apply to all the interviews I have done, and to the tech challenges as well.

Live Coding interviews

Almost if not all my live coding interviews started with a brief introduction of the interviewer, followed by an introduction of myself, and then straight to the code. Be mindful of the time box, and try to start with the simplest parts first, as you may not have time to finish all the requirements.

Read the description multiple times, interpret it, and ask the interviewer if your interpretation is correct. Think of edge cases from the start, but don’t waste too much time thinking about them, they will appear during the test. Ask the interviewer if you are allowed to view the documentation for the language you will be using during the live coding, some interviewers allow not only this but googling for some specific scenarios.

In a live coding session, it is almost impossible to have a perfect code. You most likely won’t have the best variable names, and it will probably be a single file. Try to separate the concern as much as you can, either by creating classes in the same file, or by separating them into different methods / functions.

Note: all my live coding experiences were with non-functional languages. It is possible that experiences with functional live coding interviews will differ from this.

While you write your code, remember to ask questions, even if you think the answer is obvious. Most of the times, the interviewer wants to understand how you work in a pair-programming environment.

Another thing that is very important is to test your code as you write it. If you leave this step to when you finish the code, it could happen that part of your code is wrong, and you will have to refactor a good part of it. Catching errors before will benefit you and decrease the time you take on fixing them.

Hacker Rank/Leet Code challenges

Sometimes, the companies will have a challenge before going to a live coding session, or the challenge will be the only technical step in the process.

If you receive a challenge, it may happen to be one with a very weird algorithm that you may never use in your job. Don’t be afraid of them, study algorithms and data structures before. It is possible that the challenge could include more than a single problem, mostly unrelated problems.

Most of the times, once you open the challenge, you have to complete it in a single session. This means that even if you close the window, the timer will continue, and you may lose the chance to work on the problem again.

Again, be mindful of your time, and only start the challenge when you have a time window to actually work on that without interruptions.

In this step, most of the companies don’t allow using Google, but some live coding platforms include the language’s documentation on the sidebar for reference, so use it as much as you can when you are not sure about something.

Code projects

This is the type of test I prefer. You will receive a description of a project you will have to complete, the required features, and some times edge cases and examples to test the code with.

From my experience, most companies will give you about a week to complete the assignment, but this is sometimes flexible, so if you think you will need more time, ask the company and explain the reason.

Read the requirements multiple times. Choose the language you are most familiar with, if possible (sometimes, a specific language is required by the company). Make sure to use git (some companies ask you to anonymize the project, so remember to change your git configuration to use an anonymized email and name for the commits), this will help you and the person reviewing the project to see your progress, or if you need to revert something, it is easier with git.

With code projects, you will be able to search, design, and refactor multiple times the code you are writing. Do that, as much as you need. Start with the basic requirements, structure it in a way that you can do the required features first, and then refactor it to follow the known good practices (SOLID specially).

A very important step that a lot of people forget is to document your project. Add a README.md, include the reasoning behind your design, the chosen language, and the decisions you made. Include the way to run the project, a sample response, and if it is an API, include the API reference (endpoints, response codes and bodies, expected payload, etc).

Architecture screenings

This is similar to live coding: you will have a fixed amount of time, and usually the interview starts with the interviewer introducing themselves, and then you introducing yourself.

Then they will describe a problem, and just like the live coding, be sure to confirm with them if you understood the requirements, the constraints, etc.

Start with the basics, with a simple architecture, and build up from there. The interviewer will also add more challenges during the interview, so there is no need to try to find the perfect solution at first. Give an overall architecture, and improve it.

General preparation and tips

Before any technical interview, read about data structures and algorithms, try to apply them to some sample code. This will help you choose the appropriate structure during the interview.

Try to stay calm during the interview - I know this is very difficult, specially when you really like the company or the job. The more anxious and nervous you are, the chances of forgetting something important are higher.

What I usually do right before interviews is to have my bottle of water prepared, my phone on DND, if not turned off, and notify people you live with that the interview will start. I try to join the meeting around 5 minutes before the scheduled time, and while I wait for the other party to join, I read LinkedIn posts. This helps me calm down a bit.

Check if your laptop has enough battery (better yet if plugged in), and your headset as well. Test your camera and microphone before joining.

At the end of the interview, usually there is a time for you to ask them questions. Prepare yourself beforehand, have a note with the questions you plan to ask. Here are some common questions I usually like to ask:

Is there space for growth inside the company?
- Point out if you want to follow the specialist/staff/architectural side, or the management side
What are the challenges the company faced?
What languages are used in the company?
What observability tools are used by the engineering teams?
What is the balance between new features, maintenance, and tech debts / refactors?
How is the team composed? Is there a dedicated product person, QA, designer, etc
How does the average day look like in this position?
How is the onboarding process once you join the company? Both technical and product-wise
What do you like most at the company?
What meetings does the team have?
How does the team handle documentation?
Next steps in the process

Select up to 4 questions to make, otherwise you might waste too much time on them.

Other resources

Here are some resources that could help you study and prepare for technical interviews:

System Design - useful for architectural screenings
Tech Interview Handbook
The Software Architecture Chronicles
Hello Algo - useful to study algorithms and data structures
CodeCrafters.io
kdn251/interviews
Roadmap.sh