Interview guides · Amaris Consulting

Amaris Consulting Software Engineer Interview Guide

Amaris Consulting Software Engineer interview guide: four reported rounds, question walkthroughs, a seven-day plan and consulting-fit stories.

The 60-second brief

Amaris Consulting is described by candidates as a project-based consultancy: engineers are assigned to client projects rather than to a single product. The client work candidates describe is varied and international, and includes automation platforms, data pipelines, robotics, quality assurance frameworks, and internal tools that standardise web operations. Some roles are specialised, for example an SEO-focused Software Engineer who automates audits. As a Software Engineer you would build and maintain whatever the assigned project needs, work alongside other engineers, project managers and sometimes the client's own teams, and document the work so it stays usable after you move on.

This guide is for engineers preparing for the Software Engineer loop at Amaris Consulting, particularly mid-level candidates working in TypeScript, JavaScript, Python or Go. It covers the four reported rounds, thorough answer plans for the reported behavioral and consulting-fit questions, and a seven-day schedule that also covers the technical questions (performance, runtime behaviour, debugging, API integration and automation design).

Candidates report four stages over roughly three to five weeks: a Talent Acquisition Screen, Technical Assessments, Manager Interviews and an Offer Discussion. They add that the order can shift depending on how urgent the client project is.

Focus areas

JavaScript
React
Programming interviews

Overview

Two things shape preparation for this loop. First, the work is project-based, so the same engineer might spend one assignment on an automation pipeline and the next on a client-facing product. Candidates describe questions that test the technology on your resume (JavaScript, React, REST APIs and general programming), plus design prompts that mirror consulting work, such as monitoring website Core Web Vitals, automating a manual SEO audit, or integrating an external API into a legacy codebase.

Second, candidates describe a consulting dimension that runs alongside the technical one: relating code to a client's goals, explaining technical debt or complexity to a project manager, and staying professional under pressure. Several reported questions are behavioral: learning a tool under a deadline, explaining a concept to a non-technical stakeholder, disagreeing with a client or manager, adapting to a new team, and why consulting rather than product work. Treat these as seriously as the coding, and build a short bank of stories that each end in a concrete outcome.

The listed requirements are a strong primary language (TypeScript, JavaScript, Python or Go), API development experience, and working knowledge of CI/CD and a cloud platform (AWS, Azure or GCP). Headless architectures, data pipelines, technical SEO and robotics are mentioned as pluses. Choose one language you can defend in depth, keep one project per technology on your resume that you can explain down to the edge cases, and be ready to say why you chose each framework, database design or deployment approach, not just what you used.

Candidates also report that a coding test is common, either a take-home or a live session, and that scheduling can drag because roles are matched to client projects. Plan for both coding formats, keep your communication prompt and polite throughout, and use the later stages to ask what the actual project is.

The Amaris Consulting interview process

The stages below are what candidates describe, in the order they report; the sequence can change with the urgency of the client project, and the reported process runs roughly three to five weeks.

Talent Acquisition Screen

Candidates describe the Talent Acquisition Screen as an initial check of fit and qualifications. No specific questions are tied to this stage in candidate reports, so prepare for a conversation about your background: the languages and platforms on your resume, the kind of project you want, and your reasons for choosing consulting. Because roles are matched to client projects, a clear account of your strongest stack and your availability helps the match.

What to demonstrate

Fit and qualifications for the role, which is how candidates describe the stage
How clearly you summarise your background and the technologies you list
Professional conduct, including punctual and prompt replies, which candidates mention because scheduling can slip

How to prepare

Write a short career summary that names your primary language (TypeScript, JavaScript, Python or Go) and one project with a measurable result.
Prepare an honest answer on why you want consulting work rather than product work, with one or two kinds of client project that interest you.
If you apply in a non-English-speaking country, practise the same summary in English, since candidates report part of the process may run in English.
Answer scheduling messages quickly and send a short thank-you note after the call.

Technical Assessments

Candidates report one or more technical assessments, often a coding test that can be a take-home task or a live coding session, along with direct questions about the technologies on your resume. Reported topic areas are JavaScript, React, REST APIs, OOP principles, data structures and algorithms, plus system design topics such as microservices, API design and cloud architecture. Some roles add deep dives into SEO engineering, robotics or quality systems. Approach it by choosing one language, practising it under realistic conditions, and preparing to explain the reasons behind your choices.

What to demonstrate

Working code, since a coding test is the format candidates report
OOP principles, data structures and algorithms
Familiarity with the stack on your resume, including REST API design
How you handled edge cases and trade-offs in code you have written before

How to prepare

Write a one-page runtime note for your strongest language covering its memory model and its concurrency tools, with one pitfall for each.
Solve coding problems on arrays, hash maps, queues and trees, then write tests and a short README as if the work were a take-home.
Prepare to describe an API you built: resources, status codes, pagination, versioning and error format.
Review the design topics for the Core Web Vitals monitoring, SEO audit automation and legacy API integration questions, and sketch each on one page.

Manager Interviews

Candidates describe Manager Interviews as conversations with management about how well you fit the team's needs. Reported themes are the consulting mindset (relating your code to the client's success, explaining technical debt or complexity in plain language, and staying composed under pressure) and how you work with project managers and clients. Approach them with two projects you can narrate in business terms, a set of stories covering disagreement and adaptation, and questions about the project you would join.

What to demonstrate

Alignment with team needs, as candidates describe the stage
Business alignment: connecting your code to the client's outcome
Communication of technical complexity to non-engineers
Professionalism: reliability and composure under pressure

How to prepare

Pick two projects you led and write, for each, the decision you owned, the alternatives you rejected and the outcome in terms of efficiency, cost or user metrics.
Rehearse stories for explaining a concept to a non-technical person, disagreeing with a technical direction, and adapting to a new team, each ending with a result.
Prepare questions about the project: its goals, its stack, who the stakeholders are and how deliverables are documented.
Research the sector of the project (candidates mention banking or fashion as examples) and note two technical challenges typical of it.

Offer Discussion

The final stage is reported as an Offer Discussion covering the job offer and project alignment. Candidates link this to the staffing side of the role, where you are matched to a specific client project, so it is the moment to confirm what the project is. Approach it as a scope conversation: make sure the assignment, the stack and your responsibilities are clear before you commit.

What to demonstrate

Project alignment: whether your skills and interests match the assignment on offer
Clarity of your questions about scope and objectives

How to prepare

List the facts you still need to know about the assignment: client domain, stack, team shape, your deliverables and how work is documented.
If anything in the role description feels vague, write the specific questions that would clarify it and ask them directly.
Decide in advance which stacks and project types you would accept, and which you would want to discuss.
Follow up politely if scheduling stalls, since candidates report delays at times.

Where candidates lose points

Describing the project you led with a vague 'we' and no decisions of your own

Before the loop, write the architecture decisions you personally made on two projects: the options considered, why you picked one, what it cost, and what you would change. Say 'I decided' and name the trade-off.

Answering the web-application performance question with a list of tricks instead of measurement

Open with how you would measure first: field and lab data, Core Web Vitals (LCP, INP, CLS), profiling, then fix the largest bottleneck and re-measure. Tie each optimisation to the metric it moves.

Presenting the legacy API integration as a happy path

Cover characterisation tests around the legacy code, an adapter layer that isolates the external contract, timeouts, retries with idempotency, error mapping, a feature flag for rollout and a rollback path.

Giving a generic answer to why consulting rather than a product company, or criticising product work

Give two specific reasons drawn from the reported nature of the work, such as variety of stacks and industries or client-facing communication, support each with something you have done, and ask about the project.

Treating the coding test as only a correctness exercise, or defending one stack rigidly

Read the requirements twice, handle edge cases, add tests and a short README, and explain your choices. Show openness to the client's way of working and give an example of moving to a new technology.

Questions & practice

Explain your experience with [specific language, e.g., TypeScript, Python, or Go] and how you handle memory ma

Medium · Technical & Domain Proficiency

Explain your experience with [specific language, e.g., TypeScript, Python, or Go] and how you handle memory management or concurrency.

Approach

Pick the language you know best and describe its runtime accurately. JavaScript/TypeScript on Node: your code runs on one thread with an event loop and non-blocking I/O, so CPU-heavy work blocks every request unless you move it to worker_threads or another process.
Python (CPython): reference counting plus a cyclic garbage collector. Because of the GIL, threads help with I/O-bound work but not CPU-bound Python code. Use multiprocessing or native extensions for CPU-bound work, and asyncio for many concurrent I/O tasks.
Go: goroutines are multiplexed onto OS threads, and memory is garbage collected. Share data through channels or protect it with sync.Mutex, pass context.Context for cancellation, and run tests with -race to catch data races.
Name leaks you have actually hit and how you found them: unbounded in-memory caches, event listeners or timers never removed, closures holding large objects, goroutines stuck on a channel. Tools: heap snapshots in Chrome DevTools, tracemalloc in Python, pprof in Go.
For JS concurrency, explain the difference between awaiting calls in a loop (sequential) and Promise.all (concurrent, rejects as soon as one promise rejects) or Promise.allSettled. Also explain how you cap concurrency against a rate-limited API.

Follow-up

A Node service's memory grows steadily until it restarts. How do you find what is holding the memory?
When would you choose threads, processes or async I/O in Python, and why?
How do you limit an operation to ten concurrent requests against an external API?

Diff a projection against the primary without per-row point reads

Hard · reconciliation · range hashing · throttling

The listing projection has drifted and some rows show a stale version. The primary holds 40,000,000 resource rows across 12,000 tenants while serving 1,200 writes and 14,000 reads per second. The obvious repair, reading each resource row and comparing its version against the projection, is correct and would eventually finish. Explain precisely why it is unacceptable here, then give a diff that finds the differing rows, state its complexity, and make it safe to run against a live primary. Replication lag is usually under 100 ms and is not bounded.

Approach

Quantify the naive cost rather than calling it slow: 40,000,000 point reads at even 0.5 ms each is over five hours serialised, and the only lever is concurrency, which is exactly what you cannot spend. The primary's pool is sized for the write path, and 40,000,000 random reads evict the buffer cache that sustains the 85 percent cache hit rate, so the audit degrades the system it is auditing.
Replace random access with one ordered pass per side. Both sides can be read in (tenant_id, resource_id) order, which is a sequential scan on each and a merge join in O(n) time and O(1) memory. For a dense diff that is the whole answer, and it reads the primary once instead of 40,000,000 times.
For the expected sparse case, compare range hashes instead of rows: partition the key space, compute per range an order-independent aggregate over hash(resource_id, version), compare aggregates, and descend only into ranges that differ. With d differing rows and branching factor B, at most d ranges mismatch per level, so the drill-down examines O(d log_B(n/d)) ranges and reads full rows only in mismatching leaves.
Aggregate with a sum modulo 2^64 or a multiset hash, never XOR. XOR is order-independent but self-cancelling, so two rows wrong in the same way, or a row duplicated on one side, leave the range aggregate matching and the range is declared clean.

Follow-up

The diff reports 900 stale rows. How do you decide between patching those rows and rebuilding the projection from resource_revision?
Same job, but the projection lives in a search index that cannot be scanned in key order. What changes?

Merge partitioned event streams into one ordered feed with bounded lateness

Hard · k-way merge · watermarks · out-of-order streams

The read-model service consumes 64 log partitions carrying about 4,000 events per second in total. Each partition is ordered within itself, but partitions drift by up to 30 seconds, and the activity feed must present a tenant's events in occurred_at order. Produce the merge. State its complexity, the buffer it requires in events and in bytes, what happens when one partition is idle, and what you do with an event that arrives after you have already emitted its position. Payloads average 1 KB.

Approach

Merge with a min-heap over the 64 partition heads keyed on (occurred_at, event_id): O(log P) per event and O(n log P) overall. The tie-break on event_id is what makes the output deterministic when two partitions carry the same millisecond, which matters because the feed is paginated and a non-deterministic order reorders pages under the reader.
Emitting the heap head is only correct once every partition has produced everything up to that timestamp, so the emit condition is a watermark: the minimum across partitions of the highest occurred_at seen, less the allowed lateness. Events are held until the watermark passes them, which is what turns individually ordered streams into a jointly ordered one.
Size the buffer from the lateness rather than guessing: 4,000 events per second times 30 seconds is 120,000 buffered events, and at 1 KB each about 120 MB of heap. That number is the real price of the ordering guarantee and belongs in front of whoever asked for it.
Handle the idle partition explicitly, because it fails the feed rather than corrupting it: a partition with no traffic never advances its own maximum, so the watermark freezes and output stops entirely. Either every partition emits a periodic idle marker carrying the broker's current time, or the watermark falls back to wall clock for a partition silent beyond a threshold.

Follow-up

The lateness budget is raised to five minutes. What is the new buffer, and what besides memory changes?
The consumer restarts. Where does it resume from, and what does the feed look like for the first 30 seconds?

Why do you want to join Amaris Consulting specifically, rather than a product-based company?

Medium · Behavioral & Cultural Fit

Approach

Answer about the consulting model candidates report for this role: being placed on client projects across different industries and stacks. Say which part of that you want, and give one piece of evidence from your own history, such as picking up a new stack quickly on a previous project.
Compare it honestly with a product company without running that company down. You get more variety and exposure to different codebases and clients, and you give up long-term ownership of one product. Say why that trade suits you at this point in your career.
Connect it to the work. Name the kind of client project or domain you would like to be placed on and the skills you would bring, such as API development, JavaScript/TypeScript and React front ends, or cloud and CI/CD.
Avoid generic lines ('I like challenges', 'great company') and reasons that are only about salary or location. One concrete reason with evidence is stronger than a list of adjectives.

Follow-up

How do you handle being moved to a new client project with a stack you do not know?
What would make you leave a consulting role for a product company?
What kind of client project would you most like to be placed on, and why?

Stop tag and share joins from fanning out a page

Medium · join fan-out · semi-joins · many-to-many

resource_tag is (resource_id, tag_id) with PK (resource_id, tag_id); resource_share is (resource_id, shared_with_user_id, permission). The tagged-and-shared listing inner-joins resource to both, filters tenant_id, tag_id = ANY($2) and shared_with_user_id = $3, orders by updated_at DESC and takes 50. Pages come back with fewer than 50 distinct resources and the total in the header is far too high. Explain the row multiplication, rewrite both the page query and the count query so each is correct, and name the index each one needs. PostgreSQL 16.

Approach

Do the arithmetic against the predicates that are actually there. An inner join emits one row per matching child row, and both joins are filtered: tag_id = ANY($2) admits only the requested tags, shared_with_user_id = $3 admits one user's share rows. So a resource holding three of the requested tags and shared with $3 once yields three rows, not one — the multiplier is its count of matching tags times its share rows for that single user, and that second factor is 1 unless the table admits duplicate (resource_id, shared_with_user_id) pairs. LIMIT 50 then limits rows rather than resources, and COUNT(*) counts pairs — the header is the product, not the population.
Reject DISTINCT as the fix. It deduplicates after the product has been built, so the planner must materialise and sort the fanned-out set before the LIMIT can apply, and it leaves any SUM or AVG in the same select list wrong.
Rewrite both filters as semi-joins, keeping resource as the only row source: AND EXISTS (SELECT 1 FROM resource_tag rt WHERE rt.resource_id = r.resource_id AND rt.tag_id = ANY($2)) and the same shape against resource_share. A semi-join stops at the first match per resource and preserves the driving index order, so ORDER BY updated_at DESC, resource_id DESC LIMIT 50 still stops after 50 rows.
Count with the same predicates and no join at all: SELECT count(*) FROM resource r WHERE r.tenant_id = $1 AND r.status = 'active' AND EXISTS (...) AND EXISTS (...). Nothing multiplies a resource, so the number is the population.

Follow-up

The filter changes from 'any of these tags' to 'all of these tags'. Rewrite it and state what it costs relative to the ANY form.
A resource can be shared with the same user twice under different permissions. Does your count change, and should it?

Can you describe a complex technical project you led and the architectural decisions you made?

Medium · Technical & Domain Proficiency

Approach

Pick one project where you owned the architecture. Open with the constraints that shaped it: users, load, team size, deadline, and anything inherited from the client or the existing system.
Walk through two or three decisions as decision, alternatives, reason. For example, a modular monolith instead of microservices because one small team deployed it, or a managed queue instead of a self-hosted broker to avoid running infrastructure.
For each decision, say what it cost: the query that got harder, the coupling you accepted, the scaling limit you knew about. A decision with no downside sounds like one you never weighed.
Close with a measured outcome (latency, error rate, deploy frequency, cost) and one decision you would change now, with the reason.
Keep your part separate from the team's. Say 'I chose' only for what you decided, and name who you had to persuade.

Follow-up

Which of those decisions would break first if load grew ten times, and what would you change?
How did you get agreement on the architecture from people who preferred another option?
What did you document so the next team could maintain it after you left the project?

How do you approach optimizing performance in a large-scale web application?

Medium · Technical & Domain Proficiency

Approach

Measure before you guess. Get real-user data split by page and device, and server latency at p95 and p99 rather than averages, so you know whether the time goes to the browser, the network or the backend.
Frontend: ship less JavaScript on first load (code splitting, tree shaking, lazy-loaded routes), compress and resize images, set Cache-Control and serve static assets from a CDN. In React, use the Profiler to find needless re-renders before adding memo or useMemo, and virtualize long lists.
Backend: find N+1 queries and missing indexes with EXPLAIN ANALYZE, pool database connections, cache hot reads with a clear invalidation rule, and move slow work (emails, reports, exports) onto a queue.
Fix the largest measured bottleneck first. Compare before and after on the same metric under the same traffic, then add a performance budget or regression check in CI so the gain holds.

Follow-up

The p99 latency doubled but the average did not move. Where do you look?
How do you decide whether a cache is worth the risk of stale data and invalidation bugs?
How would you stop a later release from undoing the improvement?

How do you ensure code quality and maintainability in a fast-paced project environment?

Medium · Technical & Domain Proficiency

Approach

Automate the checks so they do not depend on discipline under a deadline: a formatter and linter (Prettier, ESLint or the language equivalent), type checking (TypeScript strict mode, mypy) and tests, all run in CI and required before merge.
Keep pull requests small and reviewed, with a short checklist (tests added, errors handled, no secrets, docs updated). Review then stays fast enough that nobody skips it.
Test where the risk is: unit tests on business logic, a few integration tests on API contracts and database access, and end-to-end tests only on the main user paths. A large, slow end-to-end suite ends up ignored.
When a deadline forces a shortcut, make the debt explicit. File a ticket, say what it will cost later, and agree when it gets paid back.
Write decisions down (short architecture decision records, a README with setup and run steps) so whoever joins or takes over the project can maintain it.

Follow-up

Under a hard deadline, which of those practices would you drop first, and which would you never drop?
How do you bring tests into a codebase that has none?
How would you measure whether code quality on a project is improving?

How would you design an automated system to monitor and improve website Core Web Vitals?

Medium · Problem-Solving & Case Studies

Approach

Separate field data from lab data. Collect real-user LCP, INP and CLS with the web-vitals library sent to an analytics endpoint (or read Chrome UX Report data). Run Lighthouse or the PageSpeed Insights API on a schedule against key page templates for repeatable diagnostics.
Score against Google's thresholds at the 75th percentile of page loads: LCP at most 2.5 s, INP at most 200 ms, CLS at most 0.1. Aggregate by page template and by device type, because mobile and desktop results often differ.
Components: a scheduler, a pool of Lighthouse workers (headless Chrome is CPU-heavy, so limit concurrency), a time-series store for results, dashboards, and alerts when a template crosses a threshold or regresses against its baseline.
Catch regressions in CI: run Lighthouse CI with performance budgets on pull requests so a regression is stopped before release, not after users hit it.
Map each metric to the usual fixes the system can flag. LCP: slow server response, unoptimized hero image, render-blocking CSS or JS. INP: long main-thread tasks, heavy event handlers. CLS: images and embeds without reserved dimensions, late-loading fonts.

Follow-up

Lab scores look fine but field data fails. Why can they disagree, and which do you trust?
How do you keep noisy Lighthouse scores from firing false alerts?
How would you attribute a regression to a specific release?

Walk me through how you would integrate an external API into a legacy codebase.

Medium · Problem-Solving & Case Studies

Approach

Before changing the legacy code, add characterization tests around the area that will call the API. They let you show that existing behaviour did not change.
Put the external API behind an adapter (an anti-corruption layer). It exposes one interface in the legacy code's own terms and translates the vendor's data model, auth and error codes inside it, so a vendor change touches one module.
Make the call resilient: explicit connect and read timeouts; retries with exponential backoff and jitter, but only for idempotent requests or requests sent with an idempotency key; respect for 429 and Retry-After; and a circuit breaker so a slow vendor cannot tie up the legacy app's threads.
Choose sync or async. If the legacy flow cannot wait on the vendor, put the call on a queue and record its status. Keep credentials in a secrets manager, not in config files.
Roll out behind a feature flag. Test against a sandbox or recorded responses (contract tests), monitor call latency and error rate, and keep the old path until the new one is proven.

Follow-up

The vendor times out after it may already have processed the request. How do you avoid doing it twice?
The legacy code has no tests and no clear seams. Where do you start?
How do you handle the vendor changing or versioning its API?

If you were tasked with automating a manual SEO audit process, what architectural components would you use?

Medium · Problem-Solving & Case Studies

Approach

Turn each item on the manual checklist into a rule: HTTP status and redirect chains, a unique title and meta description, a single canonical tag, robots meta and robots.txt directives, hreflang pairs, broken internal links, and sitemap URLs that return non-200 or are noindexed.
Components: a scheduler; a crawler that reads the sitemap and follows internal links while honouring robots.txt and a rate limit; a deduplicated URL queue; parser workers; a rules engine; and a store keyed by crawl run and URL.
Render JavaScript only where needed. Use plain HTTP fetch and HTML parsing for most pages and a headless browser (Playwright or Puppeteer) for client-rendered ones, because rendering every URL multiplies cost and crawl time.
Keep every run so runs can be compared. Report only new and resolved issues, group them by page template (one template bug can affect thousands of URLs), and send results to a dashboard, tickets or alerts.
Optionally pull Search Console data through its API (indexing status, query performance) so issues can be ranked by traffic impact rather than by count.

Follow-up

The site has two million URLs. How do you finish a crawl in reasonable time without overloading the site?
How do you avoid flooding the team with thousands of duplicate issues from one template bug?
How would you show that the automated audit catches what the manual one caught?

How do you prioritize tasks when you have multiple technical requirements from different stakeholders?

Medium · Problem-Solving & Case Studies

Approach

Make the requests comparable first. For each one, write down who needs it, the business impact, the deadline and whether it is fixed, the effort, and what depends on it.
Rank with a stated rule, not by who pushes hardest: urgent production and security issues first, then impact relative to effort, then work that unblocks others. MoSCoW or a simple impact/effort matrix is enough.
When two stakeholders' priorities conflict, do not settle it quietly. Put the ranked list and the trade-off in front of whoever owns priority on the project (a project manager or the client lead), and get the decision recorded.
Keep the order visible and revisit it. Use a shared backlog showing the order and the reason, and tell stakeholders early when their request moves down and when they can expect it.
Back it with a real example: two requests that collided, how you ranked them, what slipped, and how the stakeholder whose item slipped responded.

Follow-up

Two stakeholders both say their request is the top priority. What do you do that afternoon?
An urgent request arrives mid-sprint. How do you decide whether it displaces planned work?
Tell me about a time your prioritization turned out to be wrong.

Can you walk me through your process for debugging a critical production issue?

Medium · Technical & Domain Proficiency

Approach

Mitigate before you diagnose. Confirm impact and severity, stop the damage with the cheapest reversible action (roll back the last deploy, turn off a feature flag, scale out, fail over), and keep stakeholders updated on status.
Build a timeline: when the symptom started and what changed around then (deploys, config, flags, traffic, a dependency, data volume, certificate expiry). Use metrics, error rates and logs linked by request or trace id.
Narrow the scope by comparing groups: which endpoints, regions, customers or versions are affected and which are not. The difference points at the cause. Check that the monitoring itself is right before trusting the alert.
Reproduce outside production with the same inputs where you can, and test one hypothesis at a time. Ship the fix with a regression test that fails without it.
Finish with a blameless postmortem: root cause, why detection took as long as it did, and action items with owners, such as a new alert or a safer deploy step.

Follow-up

Rolling back did not fix it. What do you check next?
The bug appears only under production load and you cannot reproduce it. How do you proceed?
What would you add so the next incident of this kind is detected sooner?

Suggested practice checklist

The plan follows the loop: your project stories and the language runtime first, then coding practice, then the performance, integration and automation design questions, and finally behavioral stories and a full mock. Each day ends with something you can reread before the interviews.

Day 1 — Map the loop and inventory your projects

Write the four reported rounds (Talent Acquisition Screen, Technical Assessments, Manager Interviews, Offer Discussion) and mark the one you are least ready for.
List the projects on your resume and pick two to present in depth: for each, write the architecture decisions you owned, the rejected alternatives and the result.
Write a short career summary naming your primary language (TypeScript, JavaScript, Python or Go).

Deliverable: A one-page loop map, two written project cases with decisions and outcomes, and a short career summary.

Day 2 — Language runtime: memory and concurrency

Write a one-page note for your strongest language: how memory is managed, what concurrency tools exist (event loop and promises, threads and asyncio, or goroutines and channels), and one typical bug for each.
Code a small concurrent example, such as a rate-limited batch of API calls, and test a failure case such as a timeout or shared-state race.
Say your answer aloud as you would in an interview.

Deliverable: A runtime note and a working, tested concurrency example you can explain.

Day 3 — Coding assessment practice

Treat one solution as a take-home: re-read the requirements, structure the code with clear classes or modules (OOP principles), and write a README with how to run it and what you assumed.
Revise core data structures: hash maps, queues, heaps and trees, with their complexity.

Deliverable: Two solved problems with tests and one README-ready submission.

Day 4 — Web performance, monitoring and code quality

Write the performance answer in order: measure, find the bottleneck, fix, re-measure, covering Core Web Vitals (LCP, INP, CLS), bundle size, caching, images and slow API calls.
Sketch a system that monitors Core Web Vitals automatically: scheduled lab runs, real-user data, a store of results over time, budgets, alerts and a check in CI.
Write your code quality practices for fast-moving projects: reviews, tests, linting, CI checks and short documentation.

Deliverable: A one-page performance playbook and a labelled diagram of the monitoring system.

Day 5 — Integration, automation and production debugging

Plan the integration of an external API into a legacy codebase: characterisation tests, an adapter layer, timeouts, retries with idempotency, error mapping, a feature flag and rollback.
Outline the components of an automated SEO audit: a crawler, a set of checks, a store of results, a scheduler, reporting and failure handling.
Write your production debugging sequence: confirm impact, check recent changes, form hypotheses, narrow with logs and metrics, mitigate, then fix and write a post-incident note.
Tidy your REST API design notes: resources, status codes, pagination and versioning.

Deliverable: A written integration plan, an SEO audit architecture diagram and a numbered debugging checklist.

Day 6 — Behavioral story bank

Write four stories in situation, action, result form: learning a tool under a deadline, explaining a concept to a non-technical person, disagreeing with a technical direction, and adapting to a new team.
For each story, add one metric or concrete outcome and one thing you would do differently.
Record yourself telling two of them and trim anything that is background rather than your decisions.

Deliverable: Four written stories with outcomes and two recorded run-throughs.

Day 7 — Consulting fit and full mock

Write your answers on why consulting rather than product work, and on your long-term goals, and test each against your actual history.
Practise how you decide between conflicting requests from different stakeholders, using a concrete prioritisation example.
Write questions to ask about the project, then run a full mock covering a project walkthrough, one design question and two behavioral questions, part of it in English if relevant.

Deliverable: Written consulting-fit answers, a list of project questions and notes from a full mock.

Consulting-fit stories to prepare

Candidates describe the consulting side of the loop as a significant share of the assessment: business alignment, plain-language communication with project managers and clients, and composure. The reported questions cover learning quickly, explaining concepts to non-technical people, disagreeing with a client or manager, adapting to a new team, and motivation for consulting. Prepare stories where you owned a decision and can state its result.

Why do you want to join Amaris Consulting specifically, rather than a product-based company?

Describe a time you had to learn a new framework or tool under a tight deadline.

Medium · Problem-Solving & Case Studies

Approach

Choose a real deadline and a tool that was truly new to you, such as moving from JavaScript to a Python or Go service, or adopting an unfamiliar framework on a client project. Open with two sentences on the situation and the date you had to deliver.
Show how you triaged the learning: which parts you needed on day one for the deliverable, which you deliberately postponed, and the sources you used (official docs, an existing codebase, one colleague who knew it). Describing a plan beats saying you learned fast.
Describe a small vertical slice or spike you built first to expose the unknowns early, and how you protected quality while learning, with tests, code review from someone experienced and a feature flag or staged rollout.
Close with the result and one lesson: what shipped and when, what you got wrong at first, and how you would shorten the ramp-up next time, for instance by asking for a short walkthrough sooner.

Follow-up

What did you choose not to learn, and did that decision cost you later?
How did you know the code you wrote in an unfamiliar framework was idiomatic and correct?
How do you onboard onto a new client project when you cannot spend a week studying first?

Tell me about a time you had to explain a complex technical concept to a non-technical stakeholder.

Medium · Behavioral & Cultural Fit

Approach

Pick an episode where the listener had to make a decision that depended on the concept, such as technical debt, a caching or latency trade-off, an API limit or a migration risk. State who they were and what they cared about (cost, risk, schedule, user impact).
Show the translation: start from their goal, use one concrete analogy or example from their world, and express the concept as consequences in time, money or risk instead of mechanisms. Mention what you deliberately left out and why.
Show that you checked understanding, for example by asking them to restate the trade-off, using a one-page summary or diagram, and following up in writing.
End with the decision they made and its effect. The mistake that sinks this answer is a story where you simplified until the trade-off disappeared, or one where nothing changed afterward.

Follow-up

How did you know they had understood, rather than just nodded along?
What did you leave out, and would it have changed their decision?
What do you do when the stakeholder pushes back with a business reason you had not considered?

How do you handle situations where you disagree with a client's or manager's technical direction?

Medium · Behavioral & Cultural Fit

Approach

Select a disagreement that was about a technical direction, not a personality. Start by showing you understood their position and constraints first: budget, deadline, existing systems, a contractual requirement or knowledge you lacked.
Explain how you raised your concern with evidence instead of opinion, such as a small prototype, a benchmark, a list of failure cases or a cost estimate, and how you offered two or three options with the trade-offs of each.
Make the decision process explicit: who owned the decision (for client work, usually the client or your manager), whether you escalated and how, and that you committed fully once the call was made. Mention recording the risk in a ticket or design note if you still disagreed.
Give the outcome honestly. Both outcomes can work, whether you changed their mind or they changed yours, but a story in which you were simply right and others were slow, or one where you silently went along, weakens the answer.

Follow-up

What would you do if they heard your evidence and still chose the option you thought would fail?
When would you escalate beyond your manager or client contact, and when would you not?
Tell me about a time you were the one who turned out to be wrong.

What are your long-term career aspirations, and how do you see them aligning with our consulting model?

Medium · Behavioral & Cultural Fit

Approach

Answer with a direction instead of a title: the skills and kind of responsibility you want to build over the next few years, for example broader system design, owning delivery to a client, or deeper specialisation in a field such as data pipelines or web performance.
Link that direction to what candidates describe about the consulting model: assignments across different stacks and industries, client-facing communication, and documenting work so others can reuse it. Name the one or two features that fit your direction instead of listing all of them.
Back it with evidence from your own history: a time you chose variety or a harder project over a comfortable one, or a move between stacks that taught you something specific.
Be candid about the trade-offs: rotating projects and changing contexts are part of the model. Close with a question about how engineers grow within the firm; do not assert a career ladder you have not been told about.

Follow-up

What would you want to learn on your first client project?
How would you feel about an assignment in a stack you do not prefer?
Where do you see yourself if you stayed an individual contributor rather than moving into management?

Describe a time you had to adapt to a new team or client culture quickly.

Medium · Behavioral & Cultural Fit

Approach

Choose a switch that was real, such as joining a client team with different tooling, review habits or communication norms. Describe the old context and the new one in a sentence each, and name the specific differences you noticed.
Describe how you learned the new culture on purpose: you observed how decisions were made and reviewed, asked a colleague what the unwritten rules were, read recent tickets and pull requests, and adopted their conventions for branching, meetings and status updates.
Show an early contribution that earned trust, like a small fix delivered in their process, plus one thing you adjusted in your own style and one standard you kept (testing or documentation) and how you explained it.
Finish with the result, such as the speed at which you became productive or feedback from the team, and a lesson. Avoid the vague claim that you fit in easily or criticism of the previous culture.

Follow-up

What did you choose not to change, and how did you handle that?
What would you do if the client's process slowed the work and you thought it was wasteful?
How did you get oriented in an unfamiliar codebase while adapting socially?