Atlassian Interviews

I recently participated in a technical phone screen for Atlassian. The interviewer presented a rather intriguing problem: optimizing a grocery shopping trip. The objective was to calculate the number of department visits saved by grouping items from the same department together, rather than visiting departments in the order they appeared on the shopping list. I was given a list of products with their departments and several shopping lists. I focused on clearly understanding the problem, especially how 'department visits' were counted in both the original and optimized scenarios. I believe I effectively communicated my thought process and outlined a viable strategy to solve the problem, walking through the provided examples.

My interview journey at Atlassian for a Principal Engineer position (P60) comprised six distinct rounds.

Round 1 (30 mins, Telephonic Screening)

Round 2 (45 mins, Values)

Round 3 (1 hour, Leadership Craft)

Round 4 (1 hour, System Design)

Round 5 (1 hour, Code Design)

Round 6 (1 hour, Data Structure)

My interview journey with Atlassian began after receiving a referral. The process kicked off with an initial call from the recruiter, where they outlined the interview structure, what they look for in candidates, and provided some helpful prep guides. They scheduled the subsequent rounds two weeks later, giving me ample time to prepare.

1. LLD Round

I was tasked with implementing a Snake Game, but with a slight twist: the snake wouldn't grow after every food item eaten, but rather after every nth food item (where n was a given parameter). The primary focus was on code organization, creating appropriate objects, functions, and abstractions to ensure the implementation was modular, extensible, and clean. The expected output was a snakeGame object exposing a nextMove(dirn) function, requiring me to manage the board, snake, and food state internally. Despite practicing this problem beforehand, I slightly overshot the allocated time by 5-10 minutes.

2. DSA Round

This round involved an n-ary tree structure. For any given pair of leaf nodes, I needed to find their lowest common ancestor (LCA). The interviewer heavily emphasized explaining the time complexity and maintaining continuous communication of my thought process throughout the problem-solving.

After these two rounds, it took another two weeks for them to schedule the next set of interviews, which were set for one week later.

3. HLD Round

The challenge was to design a YouTube-like homepage for a software similar to Confluence. The goal was to display the most "engaged with" documents across the organization, with the additional requirement of not showing documents I had authored or already read. This was essentially a standard leaderboard design problem. I proposed using Cassandra to store user view information for documents. One area of discussion and critical feedback revolved around the database schema design, specifically how to accurately determine the ranking of pages for a particular user and effectively filter out documents they had already viewed.

4. Values Round

This round deeply explored Atlassian's guiding principles. I had to articulate how my past experiences aligned with their values. For instance, for the value "be the change you seek," I needed to recount a time I initiated a significant change within my previous company.

5. Manager Round

Similar to the values round, this interview focused more intensely on my previous work experience. The manager thoroughly questioned my past projects, looking for specific examples of how I embodied Atlassian's values within those projects. It was crucial to demonstrate a comprehensive understanding of all the work I had done.

Finally, after a couple more weeks for internal discussions and hiring committee reviews, I received the offer.

My interview at Atlassian for the Principal Engineer P50 band was a comprehensive process that tested my system design and problem-solving skills. The interview started with five system design questions, each requiring a deep understanding of scalability, consistency, and data management. For example, I was asked to design a social media platform similar to Facebook, focusing on efficiently fetching friends count for each post. The second question involved identifying issues with a Google Docs-like system using a load balancer in round-robin mode. The third question explored eventual vs. strong consistency in different system scenarios. The fourth question dealt with a document signing system where notifications were lost, and I had to devise a solution to re-send them. The fifth question required calculating throughput in a system pipeline with varying processing capacities. The interview concluded with a coding question where I had to analyze office attendance logs to identify violations in entry and exit patterns.

My interview process at Atlassian started with a Karat round that included 5 system design rapid-fire questions, 2 coding questions, and I was able to code and run the first one but only discussed the approach for the second due to time constraints. In the Code Design round, I was tasked with managing a Customer Support service where agents receive ratings and needed to maintain this information to return a list of agents based on their average rating in decreasing order. The Data Structures round asked me to find the closest group (department) for a set of employees within an organisational hierarchy. The HLD round focused on a Popular Tagging System, emphasizing scaling tag-based search and popular tags. The Management round involved standard leadership questions and examples of projects with end-to-end ownership, along with scenario-based questions on mentorship and process changes. The Values round covered one question from each Atlassian value with follow-ups. My Data Structures round went ok-ish as I only solved the first part of the problem, taking more time than expected, leaving no time for follow-ups. The Management round had some concerns as the Senior Manager wasn't impressed with my answer on explaining a feature with end-to-end ownership. The rest of the interviews went well, and the interviewers seemed happy at the end.

Applied to multiple SDE2 openings and received a call from a recruiter, marking the start of the interview process. The journey began with a Karat interview on Day 1, which focused on system design questions. The candidate tackled challenges related to implementing a friend-count feature for a Facebook clone, discussing scalability for a rapidly growing platform. They also addressed a load balancing issue in a Google Docs clone, evaluating consistency models for various applications, and solving a bug tracking scenario involving missing IDs.

Day 6 brought a Data Structures interview where the candidate was asked to determine the minimum latency between services in a network, leading to a discussion on Dijkstra's algorithm and its advantages over DFS and BFS. On Day 7, a Code Design interview focused on building a customer satisfaction system, with the candidate following Test-Driven Development (TDD) principles as advised by the recruiter.

Day 13 featured another System Design interview for a Tagging Management Service, emphasizing product-agnostic design and technologies like SQS, RabbitMQ, and Kafka. The candidate received feedback on the design's completeness. The Managerial Interview on Day 16 was standard, while the Values Interview on Day 20 aligned with LeetCode-discussed questions. The process concluded with a team matching call and ultimately, an offer was accepted.

Status: B.Tech (Tier-3) Position: SDE-2 in FAANG+ Experience: 4 years

APPLICATION

Applied on careers portal for P40 role without any referral. Recruiter reached out in few days to discuss preliminary details like compensation expectation, reason to switch, etc.

ROUND-1 Karat

This was a screening round by 3rd party which involved 5 rapid fire system design questions and 2 easy-medium DSA questions.

Feedback: Cleared

ROUND-2 DSA

Write following methods - increasePopularity(content id), decreasePopularity(content id), getMostPopular(). Follow-ups included increasing/decreasing popularity by 'x' not by 1 and tie-breaker strategies.

Feedback: High Confidence, P40

ROUND-3 Code Design

Write following methods - addAgentRating(agent id), getSortedAgentRatingsList(). Follow-ups included adding agent rating for a given month, getting sorted agent list for a month, tie-breaker strategies, and concurrency.

Feedback: High Confidence, P40

ROUND-4 System Design

Design popular K feeds in confluence. Follow-ups included popularity score calculation strategies, support for querying in windows and updating dashboards of users in real-time.

Feedback: High Confidence, P50

ROUND-5 Management

Situation based questions like when you owned a project end-to-end, when you improved efficiency, when project scope increased, when you pushed back someone, etc.

Feedback: High Confidence, P40

ROUND-6 Values

Situation based questions like when you mentored someone, conflict with someone, shipped any bug to customer, project deprioritized, etc.

Feedback: No Hire

Conclusion

Recruiter reached out after Round-4 that openings are already filled but you can still give remaining two rounds and we will consider your application in 2-3 weeks when new positions come.

After all the rounds finished, recruiter provided feedback. I told the recruiter that my values round went even better than management round; their interviewer had 10 years of experience, still sitting on P40 role and joined Atlassian less than a year ago which is a big question on the credibility of their feedback. The feedback isn't even consistent with rest of the rounds. The interviewer asked me to answer either question A or question B and in the feedback I could see the negative points were that question B's response were missing and question A's response was good - I was given an OR condition and evaulation was for AND.

This can very well be a tactic to reject applications since positions were already filled.

I recently interviewed for an SDE-2 Backend Engineer position at Atlassian. The process involved six distinct rounds, starting with a Karat screening.

Round 1: Karat Screening This round included 5 system design questions and 2 DSA questions. I managed to solve one of the DSA questions completely. The verdict for this round was 'Hire'.

Round 2: Code Design The focus of this round was on code design, where I was tasked with designing the classic Snake Game. I received a 'Strong hire' verdict for my approach.

Round 3: DSA This round delved into Data Structures and Algorithms, with a specific problem on 'Stock Price Fluctuation'. I performed well and secured a 'Strong hire'.

Round 4: System Design I faced a standard tag design problem in this system design round, for which I received a 'Hire' verdict.

Round 5: Behavioral This round focused on standard leadership questions, and I was given a 'Hire' verdict.

Round 6: Values The final interview round was based on Atlassian's five core values, concluding with a 'Hire' verdict.

Despite clearing all individual rounds with positive feedback, the hiring committee ultimately decided to reject my application.

Coding Round 1 - the team that maintains the Atlassian employee directory. At Atlassian - there are multiple groups, and each can have one or more groups. Every employee is part of a group. You are tasked with designing a system that could find the closest common parent group given a target set of employees in the organization.

Coding Round 2 - some movie and screening related question(can't remember exactly)

System design - Confluence feeds based on popularity

Ghosted after these three rounds.

Hi peeps, giving back to this amazing community.

Company : Atlassian Role : P40 Years of experience : 4 Prev company : FAANG Prev Ctc : 45

Recruiter reached out on Linkedin.

First round : Karat screening. You can schedule this round as per your availability and can redo one more time if it didn't go that well. 2 medium dsa questions followed by rapid fire basic system design and dsa questions.

Second round : DSA . One medium problem with 3 followups, third followup being hard. Question was to maintain playlists of songs against users and return top k songs by number of users.

Third round : Low level design. Nokia snake game problem. Expectation is to ask all clarifying questions, snake behaviour on boundary etc. Clean working code is expected with modularity.

Fourth round : High level design. Build a tag management system for Atlassian services. Discussion was around apis , database schema, optimizations, scalability.

Fifth round : Values round. Need to give examples from professional life revolving around Atlassian core values.

Sixth round : Managerial round. Similar to values round with in depth discussion. Need to answer in STAR format.

Entire process took around 1.5 month. Interviewers are friendly and knowledgable.

Compensation : 73 LPA [44L base, 6.6L bonus, 18L stocks and 5L JB] I had no competing offers so couldn't negotiate better.

All the best!!

Round 1: Karat Screening Round All are available or similar on LeetCode.

1 LC Medium 5 Multiple choice questions on system design

Round 2: Code Design Design a Middleware Router

Round 3: Data Structures

Commodity Prices Imagine you are given a stream of data points consisting of <timestamp, commodityPrice> you are supposed to return the maxCommodityPrice at any point in time.

The timestamps in the stream can be out of order, or there can be duplicate timestamps, we need to update the commodityPrice at that particular timestamp if an entry for the timestamp already exists Create an in-memory solution tailored to prioritize frequent reads and writes for the given problem statement

Can we reduce the time complexity of the getMaxCommodityPrice to O(1) if the language does not support it? This can be done using a variable to keep the maxPrice value, but we need to update it when performing the upsert operations

Round 4: System Design

Atlassian has a number of different products, each containing different types of content. As an example, let’s look at three of our products:

Jira – Issues
Confluence – Pages
Bitbucket – Pull requests

We want to build a system that allows users to tag content from different products, and then to view content by tags. A goal of this system is that it should be built on a product-agnostic way, so that we could add new products in the future without a large amount of work.

There are three key experiences that we want to build here:

1. As a user, I can add, remove and update tags on content
2. As a user, I can click on a tag and see all content that has been associated with that tag
3. As a user, I can see a dashboard of popular tags

Imagine that you are on a team that needs to design and build the system to power this experience.

Round 4 : Result Awaited

The interview involved a single technical question described in detail below. The problem, titled 'Thrilling Teleporters', required determining if a player could reach the end of a board given teleporter configurations, die rolls, a starting square, and an ending square. Multiple examples and test cases were provided to illustrate the problem.

Round 1: Karat Screening Round
Don't remember the exact questions, but all are available or similar on LeetCode.

• 1 LC Medium
• 5 Multiple choice questions on system design

Round 2: Code Design
Agent Rating system: Return all of the agents and the average rating each one has received, ordered highest to lowest.

Round 3: Data Structures
Imagine you are the team that maintains the Atlassian employee directory.

At Atlassian, there are multiple groups, and each can have one or more groups. Every employee is part of a group.

You are tasked with designing a system that could find the closest common parent group, given a target set of employees in the organization.

Round 4: System Design
Design a system that allows users to pick a favorite color and share it with friends.

Round 5: Managerial
Questions around previous experience.

Round 6: Values
Questions around Atlassian values.

Do not take the Managerial and Values rounds lightly. These are pretty serious for P50+ roles and can downgrade or reject candidates based on these two rounds.

Overall, the experience took around 2 months and 1 day from verbal offer to the actual one.

Karat Round: 5 Sysytem design questions and 1 DSA question related to Djikstra Algo

Round 1: Interviewer asked to write a functionality about Customer care agents rating and display via sorted asc or desc order per overall ratings. Focus: Try to test your code in JUnits. Status: HIRE

Round 2: Company heriarchy related to LCA Status: No HIRE / Lean HIRE

Recruiter called and informed I didn't perform well, We aren't moving forward.

After 2 weeks , He called and informed I understood the feedback in a wrong way. We are moving forward with you're interview process.

Round 3(System design): Twitter Hashtag , How it works He focused more API design, Database optimization(grilled about Sharding and Indexing) Focus: Try to focus more o API design and Database optimization. Twist: called Recriter about feedback, He informed interviewer who interviewed me went on vacation for 2 weeks didn't update my feedback. Also mentioned that we are end of quarter and hired enough people. We are putting on hold, Someone from our team might reach out in future if they're any opening. *** After two weeks** Recruiter reached out again and informed that we'll be conducting Management and values interview on same day.

Management Interview: Went well.

Here is the problem I didn't performed well in Values interview, Whenever she is asking I am talking about techical terms and project details. She gave hints couple of times but ignored.

Focus: Don't take the Values interview too lightly it's also important, Please prepare for it. Don't perform like me as an idiot who almost saw a checkered flag but didn't crossed the final line.

Twist:Also called recruiter to check is they focus on values interview feedback immediately after the interview was done. He informed that you're 2nd round feedback is not good they might reject because of this.

In the first place why did they interviewd me for further rounds?

Feeling bad about myself almost daily why I gave shitty answers in values interview.

I recently interviewed at Atlassian for a P40 role. The process consisted of 5 rounds:

YOE ~ 4
Recruiter reached out through Linkedin.

1. Round 1: DSA
   Variant of all O(1). There was a followup as well but don't remember that right now.
2. Round 2: Rating System (LLD)
   The task involved designing a system to rate and calculate a list of customer care reps sorted by their avg rating.
   Followup -
   Different tie breaker conditions.
   How to handle in case of concurrent env.
3. Round 3: System Design (HLD)
   This round revolved around designing a tagging system, and extension was creating a dashboard for top k tags by popularity.
   I was grilled on API endpoints (http methods used, what and why for params/request body, pagination etc), kafka vs sqs vs rabbitmq, cassandra/dynamodb vs postgres for storing tags data.
   Was using flink + redis sorted set as the latency requirements for top k tags was < 5 mins, so had to explain those choices over alternatives.
4. Round 4: Values
   Atlassian has 5 values, 1 question from each.
5. Round 5: Managerial
   This went for 70 mins, non-technical but in depth questions on the work you do. Should highlight impact. Amazon LPs are a great resource to prep for these kind of rounds.

Outcome
Got an offer after ~2 weeks, team match took 2 days.
Atlassian's evaluation is different as they look for red flags even if solution might be correct. I was not able to complete followups for round 2 and discussed orally (concurrency), but they were looking a lot more at thought process and conceptual understanding instead of correctness of solution.

Atlassian P50 / P40 Interview Experience

YOE: 8+ years
Prep time: ~3 months

Karat Qualifying Round 1

Format:

• 5 design questions (each ~2–3 mins)
  • All scenario-based.
  • Example: What will you do in a case where the latency is high? What all optimisations can be done in that scenario?

Coding Question:

Given a string and a target number, count characters and split into lines without breaking words.

Example:

Str = "Hey there. Hello world"
Target = 10
Output:
[
"Hey there.",
"Hello ",
"world"
]

My experience:

• Had a brain-fade moment. Couldn't complete it despite preparing for this question.
• Ran into time limits.

Verdict:

• Self-assessment: No hire
• Actual: No hire

Note:

• Checked with Atlassian recruiter and got a chance to redo the round.

Karat Qualifying Round 2 (Redo)

Format:

• Same style of design scenario questions.
• Coding question (forgot the exact one).

My experience:

• Completed the question.
• Handled all edge cases.

Verdict:

• Self-assessment: Hire
• Actual: Hire

DS Round

Question:

• All O(1) Data Structure – Leetcode

My experience:

• Initially gave an O(log n) solution.
• Interviewer asked to optimize to O(1).
• Struggled with O(1) approach, complicated the code a bit, hurt readability.
• Interviewer was helpful, guided me in places.

Follow-ups:

1. Reduce time complexity.
2. How would you improve readability?

Suggestions:

• Be clear when explaining solutions.
• Prioritize code readability.
• Interviewers check line-by-line quality and complexity.

Verdict:

• Self-assessment: Strong Hire
• Actual: Lean Hire

Coding Round

Question:

Write scalable and extensible code for a subscription management service.

Scenario:

• JIRA: $10/month
• CONFLUENCE: $7.5/month
• BITBUCKET: $8/month
• Users can buy any combination.
• For a given year, calculate monthly billing based on usage.

Follow-ups:

1. How would you handle discounts?
2. How would you handle trial periods (extensible design)?
   • Example:
     • JIRA: 14 days
     • CONFLUENCE: 30 days
     • BITBUCKET: 7 days

Suggestions:

• Be ready to write clean, extensible code in your chosen language.
• Interviewers look at how many lines you'd need to change to support new requirements.

Verdict:

• Self-assessment: Strong Hire
• Actual: Strong Hire

System Design Round

Question:

Design a tagging system that supports adding tags across different products in Atlassian. Consider the scale of adding tags is heavy.

My experience:

• Prepared for scalability discussions (partitioning, caching, etc.).
• Interviewer focused primarily on API design and DB schema.
• Spent a lot of time on API details.
• Didn't get to cover scalability deeply.
• Overall went fine, but had a few hiccups in API design.

Suggestions:

• Take your time explaining.
• Be clear and methodical.
• Even one hiccup gets noted and can lead to "no hire" or a downgrade.

Verdict:

• Self-assessment: Hire
• Actual: Lean Hire

Note:

• Got downgraded from P50 to P40 after this round.

Managerial Round

Focus:

• Walkthrough of projects.

Suggestions:

• Use the STAR method (Situation, Task, Action, Result).
• Tell your experience like a story.

Verdict:

• Self-assessment: Hire
• Actual: Hire

Values Round

Focus:

• Behavioral questions.

Suggestions:

• Again, use the STAR method.
• Keep answers crisp—5 to 10 mins max per question (unlike the Managerial round where detail is welcome).

Verdict:

• Self-assessment: Hire
• Actual: Hire

Final Status

• Overall feedback: Good to go based on the rounds.
• Currently waiting on feedback from the hiring committee and team matching.

Key Takeaways and Suggestions

• For design/coding rounds, practice explaining your solution clearly, with trade-offs.
• Be ready for real-world scenario questions that test your judgment, not just algorithms.
• Prioritize readability and extensibility in code—think how it evolves with requirements.
• For system design, ask clarifying questions up front: "Do you want to focus on APIs, DB design, or scaling?"
• Use the STAR method for behavioral and managerial rounds.
• Manage your time carefully in Karat rounds—practice keeping calm under time pressure.

I hope this post helps others in their preparation. Feel free to ask if you want more detail about any round!

Start

• Was reached out to by the recruiter on linkedIN
• Was informed that there would be total 5-6 rounds
• Initial basic PS was done

Eliminatory Karat round

• This was a 1 hour standard Karat round
  • 10 mins: Intro, Projects, Current Work
  • 15 mins: Technical questions (OS, Design, Networking, etc.)
  • 30mins: 2 DSA questions
• Status: PASSED

DSA Round

• Was asked the variant of all O(1) question
• was able to tell the approach and TC, SC and final code
• Optimised it and gave the approach
• Some manual TC did not passed, minor issue in the code
  • But the interviewer said that they were aligned overall

Design Round

• Was asked to design an aggregation layer for a company data
  • Need avg and max metrics
  • Discussed and came up with the approach
  • Was able to code out the working solution
• A follow-up was asked
  • Able to handle the increased scope with minor changes

Got the rejection mail couple of days later. Recruiter said that they won't be moving forward. No further feedback shared.

GRIND CONTINUES .....

Experience from Atlassian P40 Interview Process

I recently interviewed at Atlassian for a P40 role. The process consisted of approximately six rounds. Here's a detailed breakdown of my experience:

1. Karat Round

• This round included questions commonly repeated in Atlassian interviews. You can find examples here: Karat Questions.

2. Round 1: Rating System

• The task involved designing a system to calculate the average rating, with multiple follow-up questions and discussions.
• For reference, here’s a link to a similar problem: Rating System Problem.

3. Round 2: Population Question

• The challenge centered on a classic Atlassian problem: implementing a +1/-1 population tracker.
• The follow-up task involved printing the top K values. The approach didn’t need to be highly optimized; even a solution using sets was acceptable.

4. Round 3: System Design

• This round revolved around designing a tagging system. Contrary to my preparation, the discussion heavily focused on specific technologies, such as:
  • Why REST APIs over other options?
  • Database choices like Cassandra or DynamoDB.
  • Messaging services like SQS or Kafka.
• My preparation emphasized starting with a non-scaled solution and incrementally scaling, but the interviewer preferred diving deeply into specific implementations.

Outcome

I didn’t pass the system design round. The focus was very different from what I anticipated, leaning heavily towards practical knowledge of specific technologies rather than conceptual approaches to system scaling.

This experience was a valuable learning opportunity, particularly in aligning interview preparation with the expectations of such rounds.

I had system design today Lol Here is the question: find top confluence feed. You have to find feed based on likes share and view.

Below are interview questions asked in first two rounds of my interview at Atlassian for SDE-2 role.

First Round Question:

Remember the old phone game of Snake?

The snake can move up, down, left or right in a 2-dimensional board of arbitrary size. Let’s try to implement the base logic of this game. Rules: Every time moveSnake() is called, the snake moves up, down, left or right The snake’s initial size is 3 and grows by 1 every 5 moves The game ends when the snake hits itself

interface SnakeGame {
    moveSnake(snakeDirection);
    isGameOver();
}

// Assume:

1. moveSnake is valid.
2. Board size is limited.
3. Board is square.
4. Snake moves only when moveSnake is called.
5. Game ends when snake hits itself.

// Entity: Snake - Deque of coordinates GameBoard - 2D array of coordinates

// Algorithm: For collision check - Set of coordinates LinkedHashSet -

• Insertion: O(1), add(E e) -> Adds at the end
• Removal: O(1)
• Contains: O(1)

My Approach:

import java.util.*;

enum Direction {
    UP, DOWN, LEFT, RIGHT;
}

class Position {
    int x, y;

    Position(int x, int y) {
        this.x = x;
        this.y = y;
    }

    Position move(Direction dir, int boardSize) {
        Position newPos = null;
        switch (dir) {
            case UP -> {
                int newX = x - 1;
                if (newX < 0) newX = boardSize - 1;
                newPos = new Position(newX, y);
            }
            case DOWN -> {
                int newX = x + 1;
                if (newX == boardSize) newX = 0;
                newPos = new Position(newX, y);
            }
            case LEFT -> {
                int newY = y - 1;
                if (newY < 0) newY = boardSize - 1;
                newPos =  new Position(x, newY);
            }
            case RIGHT -> {
                int newY = y + 1;
                if (newY == boardSize) newY = 0;
                newPos = new Position(x, newY);
            }
        };
        return newPos;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Position newPos)) return false;
        return (this.x == newPos.x && this.y == newPos.y);
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

interface SnakeGame {
    void moveSnake(Direction dir);
    boolean isGameOver();
}

class SnakeGameImpl implements SnakeGame {

    public final int snakeInitialSize;
    public final int size;
    public final Deque<Position> body;
    public final Set<Position> bodySet;
    public boolean gameOver = false;
    public int move;

    public SnakeGameImpl(int boardSize) {
        this.size = boardSize;
        this.body = new LinkedList<>(); // Note: Last position denotes head
        this.bodySet = new HashSet<>();
        this.move = 0;
        this.snakeInitialSize = 3;
        // Initialize snake of size `snakeInitialSize`
        initializeSnake(this.snakeInitialSize);
    }

    private void initializeSnake(int snakeSize) {
        for (int i=0; i<snakeSize; ++i) {
            // TODO: Make it random
            Position pos = new Position(0, i);
            this.body.addLast(pos);
            this.bodySet.add(pos);
        }
    }

    /*
    Time Comp: O(1)
    Space Comp: O(N*N), where N is size of Board.
     */
    @Override
    public void moveSnake(Direction dir) {
        if (gameOver) return;

        Position currHead = body.peekLast();
        Position newHead = currHead.move(dir, this.size);

        // check for collision
        if (bodySet.contains(newHead)) {
            gameOver = true;
            return;
        }

        Position tail = body.peekFirst();
        boolean isGrow = (++move %5 == 0);
        if (!isGrow) {
            body.pollFirst();
            bodySet.remove(tail);
        }

        body.addLast(newHead);
        bodySet.add(newHead);
    }

    @Override
    public boolean isGameOver() {
        return gameOver;
    }

    public void printSnake() {
        for (Position pos : body) {
            System.out.printf(pos.x + " " + pos.y + ", ");
        }
        System.out.println();
//        System.out.println("Snake: " + body);
    }
}

public class Main {
    public static void main(String[] args) {
        int boardSize = 6;
        SnakeGameImpl game = new SnakeGameImpl(boardSize);
        game.printSnake();
        Direction[] moves = {
                Direction.RIGHT,
                Direction.RIGHT,
                Direction.RIGHT,
                Direction.RIGHT,
                Direction.DOWN,
                Direction.LEFT,
                Direction.UP,
        };

        for (Direction dir : moves) {
            game.moveSnake(dir);
            game.printSnake();
            if (game.isGameOver()) {
                System.out.println("Game Over");
                break;
            }
        }
    }
}

Second Round Question:

interface MostPopular {
    void increasePopularity(Integer contentId);
    Integer mostPopular();
    void decreasePopularity(Integer contentId);
}

Sample execution:

[
  popularityTracker.increasePopularity(7);
  popularityTracker.increasePopularity(7);
  popularityTracker.increasePopularity(8);
  popularityTracker.mostPopular();        // returns 7
  popularityTracker.increasePopularity(8);
  popularityTracker.increasePopularity(8);
  popularityTracker.mostPopular();        // returns 8
  popularityTracker.decreasePopularity(8);
  popularityTracker.decreasePopularity(8);
  popularityTracker.mostPopular();        // returns 7
  popularityTracker.decreasePopularity(7);
  popularityTracker.decreasePopularity(7);
  popularityTracker.decreasePopularity(8);
  popularityTracker.mostPopular();        // returns -1 since there is no content with popularity greater than 0
]

// Most popular means, contentId with heighest popularity value.

Assumptions:

1. In case of a tie: -> Return any contentId
2. Popularity of contentId can never go below zero.

Follow-up

1. Return the most recent mostPopular contentId changed

My Approach:

import java.util.*;

interface MostPopular {
    void increasePopularity(Integer contentId);
    Integer mostPopular();
    void decreasePopularity(Integer contentId);
}

class PopularityTracker implements MostPopular {
    private final HashMap<Integer, Integer> popularityMap;
    private final TreeMap<Integer, HashSet<Integer>> popularityToContentMap;
// This map is only required for follow-up question.
    private final HashMap<Integer, Integer> mostRecentMap;

    PopularityTracker() {
        popularityMap = new HashMap<>();
        mostRecentMap = new HashMap<>();
        popularityToContentMap = new TreeMap<>();
    }

    @Override
    public void increasePopularity(Integer contentId) {
        int oldPopularity = popularityMap.getOrDefault(contentId, 0);
        int newPopularity = oldPopularity + 1;

        if (oldPopularity > 0) {
            HashSet<Integer> oldSetContents = popularityToContentMap.get(oldPopularity);
            oldSetContents.remove(contentId);
            if (oldSetContents.isEmpty()) {
                popularityToContentMap.remove(oldPopularity);
            }
        }

        popularityToContentMap.computeIfAbsent(newPopularity, k -> new HashSet<>()).add(contentId);
        popularityMap.put(contentId, newPopularity);
        mostRecentMap.put(newPopularity, contentId);
    }

    @Override
    public Integer mostPopular() {
        System.out.println(popularityToContentMap);
        System.out.println("most recent map");
        System.out.println(mostRecentMap);
        if (popularityToContentMap.isEmpty())
            return -1;

// Code for first implementation
//        return popularityToContentMap.lastEntry().getValue().iterator().next();
// Code change after follow-up
        return mostRecentMap.get(popularityToContentMap.lastEntry().getKey());
    }

    @Override
    public void decreasePopularity(Integer contentId) {
        int oldPopularity = popularityMap.get(contentId);
        int newPopularity = oldPopularity - 1;

        HashSet<Integer> oldSetContents = popularityToContentMap.get(oldPopularity);
        oldSetContents.remove(contentId);
        if (oldSetContents.isEmpty()) {
            popularityToContentMap.remove(oldPopularity);
        }

        if (newPopularity > 0) {
            popularityToContentMap.computeIfAbsent(newPopularity, k -> new HashSet<>()).add(contentId);
            popularityMap.put(contentId, newPopularity);
            mostRecentMap.put(newPopularity, contentId);
        } else {
            popularityMap.remove(contentId);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        PopularityTracker popularityTracker = new PopularityTracker();
        popularityTracker.increasePopularity(7);
        popularityTracker.increasePopularity(8);
        System.out.println(popularityTracker.mostPopular());          // returns 8
        popularityTracker.increasePopularity(8);
        popularityTracker.increasePopularity(7);
        System.out.println(popularityTracker.mostPopular());          // returns 7
        popularityTracker.decreasePopularity(8);
        popularityTracker.decreasePopularity(7);
        System.out.println(popularityTracker.mostPopular());       // returns 7, since 7
    }
}

Karat Round

Scaling a Web Service (Recipe + Products)
The web service allows users to browse recipes and purchase ingredients. It recently became popular and is facing performance bottlenecks.
→ What could be the potential issues and how would you improve the system?

Compute-Intensive Animation Generation
A service animates hand-drawn characters uploaded by kids. These jobs are compute-heavy and handled by a server farm.
→ How would you reduce infrastructure/server cost while maintaining user experience?

Unreliable Third-Party API
Your service depends on a third-party API (e.g., sports stats). The API has become unreliable and impacts UX.
→ What approaches would you take to mitigate the impact and improve reliability?

IoT Device Migration to Microcontroller
You’re migrating a smart appliance from an embedded computer (with Ethernet) to a resource-constrained microcontroller.
→ What factors should you consider in this migration, both from system and network perspectives?

Cost Estimation for Short Video Platform
Users upload short (≤1 min) videos with a TTL between 5–24 hours.
→ What factors should be considered to estimate the infrastructure cost for this platform over the next year if it becomes popular?

Data Structures Round

Max Price Tracker
Stream of (timestamp, price) data points. Timestamps can be duplicate and out of order.
→ Implement a system to return the maximum price at any point. Updates should override old prices.

Code Design Round

Product Rating System
Build a system with two APIs:

    rateProduct(productId, rating)

    getAllRatings() – returns all product average ratings sorted by highest average (then productId lexicographically)
    → Design it to handle real-time ratings and querying efficiently.

Hey everyone,

I recently had Atlassian ponsite rounds and I have 13 years of experience

I had 2 onsite rounds and rest were DSA/LLD which would have happened on clearing the first 2 rounds

Here are the questions I was asked:

System Design: Design a tagging system for confluence / linkedIn/ twitter. Here intent was to drill down on each statement I made. Interviewer was asking justification for every decision and checking for the alternative approach as well.

I tried to answer with my understanding.

Leadership Craft Round:

Regular questions focused on the previous projects

complex projects tricky timnelines

Overall result: Reject

Sharing my interview experience here for the Atlassian Principal Frontend Engineer (P60).

Location: Bangalore, India

1st Round UI Coding: Build a Tab component with some variations like lazy loading content when Tab Panel is visible.

2nd Round JS Coding: Build a function to measure performance of a given function(s). I tried to use Date.now and later realised about using Performance.now group of functions. Hint: Run functions multiple time to get average running time. Also handle Sync and Async functions.

3rd Round System Design: Design Google Editor. There was more focus on Conflict resolution algorithms (OT and CRDT) and the edge cases.

Result: Rejected. Bombed 3rd round as probably didn't had good understanding about OT and CRDT algorithms.

Other interview experiences: New Relic - Lead Frontend Engineer (Reject) SurveyMonkey - Staff Frontend Engineer ( Reject )

Introduction about me : Hello all ! This is Pratyush Raj .I am currently a summer intern at Atlassian.I am a final year student at IIT Dhanbad popularly known as ISM Dhanbad . I am pursuing integrated master of technology in Mathematics and Computing . I am a machine learning enthusiast and have keen interests in artifical intelligence and NLP. That was not the part I guess you have come here to read about .. so let’s jump into the process …

HIRING FLOW : STEP1 : ORIENTATION SESSION : It was a very wonderful session conducted by the campus hiring team and team emphasising on the new wing Atlassian AI that caught my attention all throughout !

STEP2: OLT (online test) : It was a coding test . It generally consists of 2 to 3 questions medium to tough (around 1600 rating codeforces) . The questions covered were dp ,graphs and bit masking in my case .

STEP3:Tech Interview: It was a 60 min long interview . The interviewer intially gave me a question in a tricy way . There were 2 questions . In the first question the theme was to find the length of longest common subsequence and then print it . The second question was on minimum spanning tree ( the topic which is very very important but many people leave it ) . He didnt ask me directly , so yes you need to think and identify which algorithm or method should be used for the problem . I Started with the brute force and then explained him the optimal solutions . After the coding questions a couple of oops / os questions he asked me about virtual memory ,dynamic binding , constructors and destructors . They were answerable if you know the basics .

STEP4: HR interview : The interviewer was a very chill person , he made by comfortable first by asking about hobbies and stuffs and then the interview started . He asked general questions like how would you tackle a situtaiton where a teammate is not able to perform well , tell me one change you have brought to society and stuffs like that . I answered them honestly and he was happy with me

🧠 Karat Round The Karat round was structured around 5 rapid-fire system design questions followed by a coding problem.

⚙️ System Design (Rapid Fire) I don’t remember the exact questions, but the theme was mostly around:

Performance improvement Component design System scalability Trade-offs between DB, memory, and caching These were not deep-dive design rounds but tested: Quick structuring Trade-off analysis Communication of ideas

💻 Coding Problem Problem: You’re given a list of user actions like:

users : [["Alice", "Connect"], ["Bob", "Disconnect"], ["John", "Connect"]]
Goal: Group users by their action.

Expected Output:
{
    "Connect": ["Alice", "John"],
    "Disconnect": ["Bob"]
}

👨‍💻 Round 1: Technical Round 1 This round had two problems: one on interval assignment, and another on route matcher system design.

🏟️ Question 1:

Court Assignment (Interval Allocation)
Input: [[1, 4], [4, 5], [2, 4]]
Goal: Assign each interval to a court such that no overlapping intervals are on the same court. We have infine number of courts 

Expected Output:
{
    1: [[1, 4], [4, 5]],
    2: [[2, 4]]
}

Approach: Sort intervals by start time Use a min-heap to keep track of court end times Assign to the first available court or open a new one

Round 3 : Code Design - Dynamic Route Mapping

Design a system to register routes and support wildcard path matching.

Examples:****
AddRoute("/a/b/c", "value1")
getRoute("/a/*/b") // value1

AddRoute("/a", "test");
getRoute("/a") //. test

Improved Design:

Used a Trie-based structure to support wildcards Implemented logic to resolve * in any segment Discussed performance and scalability for large route sets

Hi,

• Applied via career site.
• Date of offer April'25.
• YOE: ~5

Round 1: Karat Screening

• It was a standard Karat Round with 5 question on System Design and couple of DSA questions.
• You can refer other Karat experience for similar questions, I don't recall the questions. 1 was string based, and other one was BFS based.

Round 2: Code Design

• Main question: Was asked to implement simple get and put interface for a string based key.
• Follow up: Extend the functionality to allow wild cards in the get function. for example

    put("/elonmusk/is/shit", "yes")
    get("/elonmusk/*/*")  -> yes
    get("/elonmusk/is/*") -> yes

You are expected, handle corner cases, implement design patterns, handle exceptions similar to any Machine Coding round.

Round 3: DSA

• It was dedicated DSA round, was asked 2 DSA question.
• Problem statment was confusing but if you have had grasp over Data Structure you would be able to solve this. It was Nested Ordered Map based question.

Round 4: HLD

Design a Tag Management System, was asked the multiple nity-gritties in the design.

Round 5: Values Round

Standard Behavioural questions on Atlassian Values. Be ready with multiple example from your past experiences, you will be grilled on your past experience.

Round 6: Management Round

Similar to the previous round this round was based on Behavioural, but these were not based on Atlassian these were generalised questions.

After 6 rounds, recruiter conveyed that hiring committee has taken a HIRE call.

Then the recruiter scheduled team matching call with 4 different hiring managers.

Accepted the offer.

May 2025

Experience: 3+ Years Education: BTech Tier 3 Prior Experience: similar level at FAANG

Karat Round: 5 Design Rapid fire questions. 2 Coding questions. You are expected to solve min 4/5 design questions and 1.5 coding question fully working code for first and partial second with correct approach.

Round 1: Code Design Imagine we have a customer support ticketing system. The system allows customers to rate the support agent out of 5.

To start with, write a function which accepts a rating, and another function which will get all of the agents and the average rating each one has received, ordered highest to lowest.

Follow up question: Currently your solution does not account for what happens if two agents have the same average rating [adjust wording here if they have handled it in some way]. What options are there for handling ties and how can we implement that in code?

Round 2: Data Structures

Implement a function that given a list of tennis court bookings with start and finish times, returns a plan assigning each booking to a specific court, ensuring each court is used by only one booking at a time and using the minimum amount of courts with unlimited number of courts available.

An example of the booking record might look like:

class BookingRecord:

  id: int // ID of the booking.

  start_time: int

  finish_time: int

and our function is going to look like:

List<Court> assignCourts(List<BookingRecord> bookingRecords)

Coding Design round went well. Bombed DSA round :( Although I have solved similar interval questions in past, mind froze when thinking about assigning courts to bookings. Interviewer was giving sufficient hints, but not my day probably. Feel free to post solutions.

Atlassian stands out globally not just for its world-class products like Jira and Confluence, but also for its top-tier work culture and competitive compensation. The company consistently ranks high for employee satisfaction and is among the best-paying tech firms worldwide.

Program Overview: Women in Tech (WIT) SDE Internship

Exclusively for Women, this program aims to empower women in STEM by offering valuable industry experience and potential career opportunities at Atlassian.

• $$Stipend:$$ ₹1,30,000/month
• $$Timeline:$$ Summer Internship between May and July
• $$PPO:$$ High chance of Pre-Placement Offer based on performance

Eligibility:

1. Branches: CE / CS / EEE / ECE / Mathematics and Computing
2. CGPA ≥ 7
3. No active backlogs

Recruitment Process: Step-by-Step

The Atlassian Women in Tech (WIT) Summer Internship 2025—4th Edition—was announced on August 28, 2024, with the registration window open until September 16, 2024, providing applicants with a 20-day period to submit their applications.

Tip - In this time frame, build a well-formatted, ats-friendly resume. Include terms like: Data Structures, Algorithms, Java, Python, REST APIs, Object-Oriented Programming, Agile, etc. Mention Atlassian tools if you’ve used any (e.g., Jira, Confluence)

1. Online Application

Applications were either invited through college or directly via Atlassian’s career portal.

Key Dates for the 2025 Edition:

• $$Registration Period:$$ August 28 – September 16, 2024
• $$Online Assessment:$$ September 21, 2024 (8:00 PM – 9:30 PM IST)

UPON SELECTION- Results of the OA out in a week.

• $$Engagement Sessions:$$ October 16 & 17, 2024
• $$Virtual Interviews:$$ Starting October 21, 2024 till mid Nov 2024

Given that the 2025 internship cycle has concluded, it's advisable to prepare for the 2026 edition, which is likely to follow a similar timeline. Keep an eye on Atlassian's official careers page and HackerRank event listings around August 2025 for announcements.

2. Online Assessment (OA) – HackerRank Platform

Based upon shortlisting, OA links are sent to our mails. $$Duration:$$ 90 mins $$Sections: $$3 DSA coding questions (Medium-Hard Leetcode level)

Here's a summary of each question I received:

Q1: Ordinal Power Sum – Even or Odd Given strings and an integer m, compute the product of ASCII values (raised to m) for each string, sum them, and check if the total is even or odd.

Q2: Distinct Pods with Minimum Cost Make pod counts in an array unique by only incrementing values, minimizing the total cost per increment.

Q3: Student Swap to Match Heights Make two student lines match exactly by swapping any two students; cost is min(heightA, heightB).

I finished the assessment in about 20 minutes, and received the mail for further rounds on Sep 27, 2024.

Document verification: Transcripts and other necessary documents are requested to be uploaded.

3. Technical Interview Round

• Started Oct 21, 2024
• $$Duration:$$ 60 minutes
• No. of questions asked- 1-2
• $$Focus:$$

1. Clear approach to the question
2. Time and space complexity, optimizations.
3. Coding following best practices- code formatting, naming conventions etc.

I was asked one graph based question which had to implemented using class. We are free to refer to Google for syntactical help. Within half an hour, results of the first round is sent to the mail. If selected, next round is scheduled for the same day.

4. Managerial and Behavioral Round (HR Round)

• Duration: 60 minutes
• Focus:

1. Behavioral questions around Atlassian’s values (“Open company, no bullshit”, “Be the change you seek”-- check website)
2. Our projects are also discussed. STAR format answers work best here.

Tip: Familiarity with Atlassian's values and a problem-solving mindset are crucial in this round.

Final results are out by night. The sooner, the better!

5. PPO and Conversion Criteria

• Performance during internship is evaluated closely.
• Regular mentorship and project impact directly influence PPO decisions.
• Clear communication, learning agility, and culture alignment matter as much as technical prowess.

🌟 Final Thoughts

Atlassian’s Women in Tech Internship is a golden opportunity to launch your career in a globally respected tech company. With a lucrative stipend and real PPO potential, this program is not just an internship – it's a fast track to becoming a full-time SDE at one of the best workplaces in tech.

🔼 If you found this helpful or interesting, feel free to leave an $$upvote$$! Helps others discover it too. :)

It consisted of 2 section

1. He fired somewhere like 5-7 question on scenerio based design , like given scenerio if present flow work or not / what can done to build etc like this.
2. DSA question expection was to implement 1 question and explaon approach for the second if time is there implement it it also has some sort of partial/ step marking as well.

Question 1 : was given a word and a list of words we need to find if given word can be formed from same character present in any word of the list.

Word1 : sky
list - <cry,edt,srk,srrfkrey>
-> answer = srrfkrey

string findSimilar(vector<string> words,string note){
  unordered_map<char, int>noteFreq;
  for(auto ch:note){
    noteFreq[ch]++;
  }
  unordered_map<char, int>wordFreq;
  unordered_map<char, int>duplicateNoteFreq;
  
  bool notFound= false;
  for(string word:words){
    duplicateNoteFreq = noteFreq;
    notFound = false;
    for(auto ch:word){
      duplicateNoteFreq[ch]--;
      if(duplicateNoteFreq[ch]<0){
        notFound= true;
      }
    }
    if(!notFound){
      return word;
    }
  }
  return "-";
  
}

Question 2:

grid1 = [
    ['b', 'b', 'b', 'a', 'l', 'l', 'o', 'o'],
    ['b', 'a', 'c', 'c', 'e', 's', 'c', 'n'],
    ['a', 'l', 't', 'e', 'w', 'c', 'e', 'w'],
    ['a', 'l', 'o', 's', 's', 'e', 'c', 'c'],
    ['w', 'o', 'o', 'w', 'a', 'c', 'a', 'w'],
    ['i', 'b', 'w', 'o', 'w', 'w', 'o', 'w']
]
word1_1 = "access"      # [(1, 1), (1, 2), (1, 3), (2, 3), (3, 3), (3, 4)]
word1_2 = "balloon"     # [(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 7)]

Able to do question this impl but need some extra time to make it working

void bfsHelper(vector<vector<char>>grid1,string word,int ind, vector<pair<int,int>>&ans , vector<vector<bool>>visited, int r,int c, int row, int col){
  
  if(ind == word.length())
  return;
  int dx[2]={0,-1};
  int dy[2]={1, 0};
  for(int i =0;i<2;i++){
    int xx = r+dx[i];
    int yy = c +dy[i];
    if(xx < row && xx >=0 && yy<col && yy>=0 ){
      if(grid1[xx][yy]==word[ind] &&   visited[r][c]== false){
        ans.push_back({xx,yy});
          visited[r][c]= true;
          bfsHelper(grid1,word,ind+1,ans,visited,xx,yy,row,col);
          ans.pop_back();
          visited[r][c]= false;
      } else {
        continue;
      }
    }
  }

  return;
  
}



vector<pair<int,int>> findPath(vector<vector<char>>grid1, string word){
  
  int row = grid1.size();
  
  int col = grid1[0].size();
  vector<vector<bool>>visited(row,vector<bool>(col,false));
  vector<pair<int,int>>ans;
  
  for(int i=0;i<row;i++){
    for(int j=0;j<col;j++){
      if(grid1[i][j]==word[0]){
        ans.push_back({i,j});
        visited[i][j]=true;
        bfsHelper(grid1,word,1,ans,visited,i,j,row,col);
                ans.pop_back();
                       visited[i][j]=false;
        
      }
      
    }
  }
  
  return ans;
}

Question 1

Input Structure:

We have two inputs: a list of available parts and a list of required parts for each robot. Each robot's required parts are stored in a dictionary where the key is the robot name and the value is a list of parts needed. Output:

We need to return a list of robot names that can be fully constructed with the available parts.

List = [ "Rosie_claw", "Rosie_sensors", "Dustie_case", "Optimus_sensors", "Rust_sensors", "Rosie_case", "Rust_case", "Optimus_speaker", "Rosie_wheels", "Dustie_case", "Dustie_arms", "Rust_claw", "Dustie_case", "Dustie_speaker", "Optimus_case", "Optimus_wheels", "Optimus_wheels", "Rust_legs", "Optimus_sensors" ] Available Parts = {"sensors", "case", "speaker", "wheels"}

output - [Optimus, Rosie]

Question 2

You work in an automated robot factory. Once robots are assembled, they are sent to the shipping center via a series of autonomous delivery carts, each of which moves packages on a one-way route.

Given input that provides the (directed) steps that each cart takes as pairs, write a function that identifies all the start locations, and a collection of all of the possible ending locations for each start location.

In this diagram, starting locations are at the top and destinations are at the bottom - i.e. the graph is directed exclusively downward.

   A          E      J       Key:  [Origins]
  / \        / \      \                 \
 B   C      F   L      M             [Destinations]
  \ /  \   /
   K     G
        / \
       H   I

paths = [ ["B", "K"], ["C", "K"], ["E", "L"], ["F", "G"], ["J", "M"], ["E", "F"], ["C", "G"], ["A", "B"], ["A", "C"], ["G", "H"], ["G", "I"] ]

Expected output (unordered):
[ "A": ["K", "H", "I"], "E": ["H", "L", "I"], "J": ["M"] ]

N: Number of pairs in the input.

Current company: FAANG
YOE: ~5yrs

R1 OA: Happened on Karat (3rd party provider)

• 1 LC medium
• 5 Multiple choice questions on system design
• OS and database related questions

R2 DSA (Onsite)

Imagine you are the team that maintains the Atlassian employee directory. 
 
At Atlassian - there are multiple groups, and each can have one or more groups. Every employee is part of a group.
 
You are tasked with designing a system that could find the closest common parent group  given a target set of employees in the organization. 
 
            Company
         /           <br/>       HR               Engg
     /   \          /          \ 
    Mona  Springs  BE          FE 
                    /  \        / \ 
                 Alice Bob  Lisa Marley
 
Input Target employees - Lisa, Marley 
Output: FE 
Input Target employees - Alice, Marley 
Output: Engg 
Input Target employees - Mona, Lisa, Bob
Output: Company

R3 LLD

• Design a ticketing management system.

R4 HLD

• Desgin a clickstream system and then extended it to tag management system.

R5 Management round

• In this round question will be asked on previous experience, prepare yourself as people get rejected in this round.

R6 Values

• situational based questions

Appeared for the attlassian Karat screening round recently and the following questions were asked:

Started with a brief introduction and format of the interview then 5 System design scenario related questions were asked in a frame of 20 mins. For example:

You are given a hospital booking management system where you have a queue of patients waiting for the slot to visit a doctor. As soon as a slot becomes available you do follwoing things:

a. Take the first person of out the waiting queue and text them the available slot details and wait for 30 mins for them to respond. b. If they respond yes then you remove them from waiting. c. If they respond no, you put them back in front of the queue.

How would you optimise such a system?

Then the interviewer jumped to the coding questions:

First Question:

You are given a 2-D array mentioning the product and its department in a supermarket and a list of item you have to purchase. You can buy the items in 2 formats:

(A) Pick items as mentioned in shopping list (this would require multiple visits to similar departments) (B) Buy all the items of a department together in one shot.

You need to find the additional hops of departments you would be having in approach a.

For example: products = [ [apple, fresh], [banana, fresh], [milk, dairy] .... ]

list = [apple, milk, banana]

Number of hops in approach a = fresh -> dairy -> fresh = 3 Number of hops in approach b = fresh -> dairy = 2

Additional hops = 1

Second Question:

You and your friends are driving to a Campground to go camping. Only 2 of you have cars, so you will be carpooling.

Routes to the campground are linear, so each location will only lead to 1 location and there will be no loops or detours. Both cars will leave from their starting locations at the same time. The first car to pass someone's location will pick them up. If both cars arrive at the same time, the person can go in either car.

Roads are provided as a directed list of connected locations with the duration (in minutes) it takes to drive between the locations. [Origin, Destination, Duration it takes to drive]

Given a list of roads, a list of starting locations and a list of people/where they live, return a collection of who will be in each car upon arrival to the Campground.

Bridgewater--(30)-->Caledonia--(15)-->New Grafton--(5)-->Campground ^ Liverpool---(10)---Milton-----(30)-----^

roads1 = [ ["Bridgewater", "Caledonia", "30"], <= The road from Bridgewater to Caledonia takes 30 minutes to drive. ["Caledonia", "New Grafton", "15"], ["New Grafton", "Campground", "5"], ["Milton", "New Grafton", "30"], ["Liverpool", "Milton", "10"] ] starts1 = ["Bridgewater", "Liverpool"] people1 = [ ["Jessie", "Bridgewater"], ["Travis", "Caledonia"], ["Jeremy", "New Grafton"], ["Katie", "Liverpool"] ]

Car1 path: (from Bridgewater): [Bridgewater(0, Jessie)->Caledonia(30, Travis)->New Grafton(45)->Campground(50)] Car2 path: (from Liverpool): [Liverpool(0, Katie)->Milton(10)->New Grafton(40, Jeremy)->Campground(45)]

Output (In any order/format): [Jessie, Travis], [Katie, Jeremy]

My interview experience began with a Karat screening for an Atlassian role. The session focused purely on algorithmic problem-solving. I was presented with two distinct coding problems. The first involved searching through a dictionary to identify words that encompassed all the letters of a given target word. The second challenge required me to implement a Depth-First Search (DFS) algorithm on a 2D array to locate specific target coordinates, and I only needed to provide one valid output.

I recently went through the interview process at Atlassian for a P40 level role. The entire process was well-structured and quite thorough, consisting of five distinct rounds. After successfully clearing the initial coding round, I proceeded to four subsequent rounds covering more coding challenges, system design, management, and cultural fit. The recruiters were exceptionally professional and detailed, proactively communicating all the questions I should expect in each upcoming round, which was incredibly helpful.

The entire interview process took approximately four months, though I believe it could have been expedited to two. I applied for a P6 (Principal) role, bringing 8 years of experience to the table.

After an initial HR call, I proceeded through six distinct interview rounds:

Coding Interviews (2 rounds, 45 minutes each, with a 15-minute break):

The interviewers paid close attention to code quality, writing tests, and my thought process, including discussing alternative solutions. I appreciated that I was allowed to use my own IDE, which really emulated a real-world work environment.

First Coding Round:

• I was asked to implement a rate limiter. I used a leaking bucket algorithm, which I had reviewed the day before.
• The next task was to modify it for per-user functionality, which I achieved by adding a concurrent hashmap to manage individual buckets.
• Finally, I had to incorporate a credit system for users if their allocated rate wasn't fully utilized. Fortunately, my existing code was quite adaptable to this requirement.
• We concluded with discussions on thread safety, JVM specifics, and how to scale the solution to a distributed system.

My outcome for this round was Strong Hire P6.

Second Coding Round:

• I tackled a problem to sort a collection, which was very similar to LeetCode's "Rank Teams by Votes".

My outcome for this round was also Strong Hire P6.

System Design (1 hour):

I was asked to design a web crawler. I did make a few initial mistakes, specifically forgetting to account for loops in the obtained links, but I quickly corrected my design after the interviewer pointed it out. For a P6 role, I felt there was no room for error or hesitation, and any misstep seemed to be noted. I generally found the judging criteria for this round to be quite biased and unrealistic.

The outcome for this round was Hire P5, which was my biggest setback.

Craft Interview (1 hour):

This round involved an in-depth discussion about my project architecture, the problems I'd faced, the trade-offs I'd made, and my responsibilities. Given my recent company-wide impact, I didn't encounter any issues here.

My outcome was Strong Hire P6.

Management Interview (1 hour):

This was a standard behavioral discussion with the hiring manager, covering my achievements, trade-offs, and conflict resolution strategies.

The outcome was In between Hire and Strong Hire P6.

Values Interview (30 minutes):

This was a slightly less in-depth behavioral round. I found that I could pretty much use the same answers from the management interview.

Despite receiving "Strong Hire" ratings for most rounds, except for system design, Atlassian didn't offer me the P6 role directly. Instead, they requested that I redo the system design interview.

Second System Design (1 hour):

This time, I was tasked with designing a tagging system specifically for Atlassian products. I felt very confident going into this, but the interviewer was extremely tedious about API design, which consumed a significant portion of my time. As a result, the final design ended up feeling somewhat hectic.

The outcome was again Hire P5.

In the end, I was low-balled to a P5 offer. I suspect this might be a common practice for them to pay less. The total compensation offered was 190k AUD base, a 15% annual bonus, and 250k USD in RSUs over four years.

I ultimately rejected the offer, primarily due to recent negative reviews I had seen on Blind and Glassdoor regarding Atlassian.

I had my interview rounds for a Senior SDE (P5) position at Atlassian in Bangalore. With 10 years of experience, primarily from Amazon, I was confident in my preparation.

Interview Rounds:

• Round 1 (Coding/DSA): I was asked to implement a Fixed Window Rate Limiter.
• Round 2 (Coding/System Design): This round involved a question similar to the All-O(1) Data Structure problem on LeetCode. Following my approach to this, we had a detailed discussion on various distributed systems scenarios related to the problem.
• Round 3 (System Design): I was tasked with designing an Image Crawler. The prompt specified it should be similar to a web crawler, but with the distinct goal of crawling and saving images.
• Round 4 (Behavioral/Values): This was a values round, focusing on cultural fit and alignment with Atlassian's principles.
• Round 5 (Hiring Manager): The final round was with the Hiring Manager, which typically assesses overall fit, career aspirations, and team alignment.

Verdict:

After all rounds, I received the verdict that I was downleveled to a P4 role instead of the Senior SDE (P5) position I applied for.

Reason & Conclusion:

The reasons provided for the downleveling were quite vague and, frankly, didn't make much sense to me. Having spent 7-8 years involved in hiring SDE 1/2/3 at Amazon, I have a clear understanding of the hiring bar and expectations for candidates. My experience leads me to believe a few things regarding Atlassian's interview process:

• Some of the technical interviewers lacked experience in conducting interviews effectively and seemed unreceptive to solutions that didn't align with their preconceived notions.
• There appeared to be a feeling of superiority or ego among some Atlassian interviewers, making them less open to different perspectives.

I genuinely feel that Atlassian could benefit significantly from improving their interview process and implementing stricter training on interview techniques and candidate evaluation. Without these improvements, they risk losing out on good candidates.

My Atlassian SDE-2 Interview Experience

I recently went through the interview process for an SDE-2 position at Atlassian, a remote role based in India. The process consisted of five distinct rounds, each designed to assess different aspects of my technical skills and cultural alignment.

Coding Round 1

My first coding round focused on implementing a Rate Limiter. This problem is considered quite standard for Atlassian interviews, so I focused on writing clean, efficient code.

Coding Round 2

The second coding round presented a variation of the "Rank Teams by Votes" problem. Instead of working with characters, I was asked to process a string representing team votes and then identify the top 3 teams based on their aggregated votes. I was familiar with the LeetCode problem, which helped me adapt to the modification quickly.

System Design Round

The System Design round was particularly insightful. The core problem was to design a tag management system for JIRA and Confluence, which is a common system design challenge at Atlassian. My approach involved starting with a thorough discussion of Functional and Non-Functional requirements. Following this, I detailed the API design, specifying protocols, and then delved into database schema design. The interviewer continuously probed into implementation details, emphasizing that a complete solution wasn't the goal, but rather a structured approach and a clear understanding of the services involved. Although I didn't get to extensively discuss high-level diagrams, I made sure to list out all the essential services required for such a system.

Management Round

This was one of the best rounds. The recruiter elaborated on Atlassian's principles and values, and we had a deep dive into my past projects, discussing how my experiences aligned with team management and leadership fit.

Cultural And Values Fit

The final round focused on cultural fit and values. Atlassian's hiring philosophy is not for a specific team, which allows for internal mobility. The questions were pretty standard HR questions. I made sure to remain polite, avoid overspeaking, and integrate the STAR method and Atlassian's company values into my responses. The recruiter was very thorough and helpful, even detailing the types of questions to expect in this round beforehand.