# US 2024/0004674 A1 · Buffering and replaying user interaction event content received at a frontend application while asynchronously loading resources supporting a page from a backend application of a multiuser collaboration tool

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2024/0004674 A1
- Document ID: US20240004674A1
- Status: Published application
- Kind: A1
- Application number: 17/853,681
- Filed: 2022-06-29
- Published: 2024-01-04
- Earliest claimed: 2022-06-29
- Assignees: Atlassian Pty Ltd.; Atlassian Inc.
- Applicants: Atlassian Pty Ltd.; Atlassian Inc.
- Inventors: Sergey Chebykin
- Web page: https://patentgrep.com/patent/US20240004674A1

## CPC

- G06F 9/451: Execution arrangements for user interfaces
- G06F 9/44521: {Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading}
- G06F 16/9574: {of access to content, e.g. by caching}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Systems and methods for servicing page requests from a cloud-based software service. In particular, page tree elements defining a page requested from a backend of a cloud-based software service can be can be transmitted in a manner that prioritizes elements and functionality likely to be interacted with by a particular user first (e.g., within a threshold time of apparent pageload completion). Other elements unlikely to be interacted with by the user may be loaded asynchronously and/or on a deferred basis. Inputs provided to these elements can be buffered by an input buffer script to capture unexpected inputs thereto.

## Claims

### Claim 1

A method of operating a backend application instantiated by interoperation of a processor and a memory allocated for the backend application by a host system, the method comprising:
receiving, at the backend application from a frontend application instantiated by a client device, a request for a page defined by an element tree comprising:
a set of user interface elements;
a set of style elements, each style element defining a presentation style for at least one of the user interface elements; and
a set of frontend-executable script elements, each defining a functionality associated with at least a respective one of the set of user interface elements;
determining, by the backend application from the request, user information associated with a user authenticated to the backend application operating the frontend application;
identifying, by the backend application from the user information, a first frontend-executable script element of the set of frontend-executable script elements likely to receive a first user input at the frontend within a first threshold time period of initiating loading of the page in the frontend;
identifying, by the backend application from the user information, a second frontend-executable script element of the set of frontend-executable script elements not likely to receive a second user input at the frontend within a second threshold time period of initiating loading of the page in the frontend;
marking the second frontend-executable script element for deferred loading;
associating an input buffer script of the element tree with a user interface element associated with the second frontend-executable script element, the input buffer script configured to receive the second user input within the second threshold period of time and buffer the second user input until the second frontend-executable script element is loaded, thereafter providing the second user input to the second frontend-executable script element as input; and
serving the element tree to the frontend application instance in response to the request.

### Claim 2 (depends on 1)

The method of claim 1, wherein identifying, by the backend application from the user information, the first frontend-executable script element of the set of frontend-executable script elements likely to receive the first user input at the frontend within the first threshold time period comprises accessing a user interaction history of the user.

### Claim 3 (depends on 1)

The method of claim 1, wherein identifying, by the backend application from the user information, the first frontend-executable script element of the set of frontend-executable script elements likely to receive the first user input at the frontend within the first threshold time period comprises accessing a user interaction history of a group of users to which the user belongs.

### Claim 4 (depends on 1)

The method of claim 1, wherein identifying, by the backend application from the user information, the first frontend-executable script element of the set of frontend-executable script elements likely to receive the first user input at the frontend within the first threshold time period comprises accessing a user interaction history of a tenant or organization to which the user belongs.

### Claim 5 (depends on 1)

The method of claim 1, wherein identifying, by the backend application from the user information, the second frontend-executable script element of the set of frontend-executable script elements likely to receive the second user input at the frontend within the second threshold time period comprises determining that the user interface element is infrequently accessed by the user.

### Claim 6 (depends on 1)

The method of claim 1, wherein the backend application is associated with a collaboration tool selected from a group consisting of:
a documentation platform;
an issue tracking platform; and
a project management platform.

### Claim 7 (depends on 1)

The method of claim 1, wherein the user information comprises a user interaction history of the user with the user interface element.

### Claim 8 (depends on 1)

The method of claim 1, wherein marking the second frontend-executable script element for deferred loading comprises modifying an attribute of an element of the element tree referencing the second frontend-executable script.

### Claim 9 (depends on 1)

The method of claim 1, wherein marking the second frontend-executable script element for deferred loading comprises transmitting the second frontend-executable script element to the frontend instance after a delay.

### Claim 10

A method of submitting a request to a backend application instantiated by interoperation of a processor and a memory, allocated for the backend application by a host system, the method comprising:
transmitting, to the backend application from a frontend application instantiated by a client device, a request for a page the request comprising user information describing a user of the client device authenticated to the frontend application;
receiving in response to the request, a first response comprising:
a first set of user interface elements; and
a first set of frontend-executable script elements comprising:
an identifier identifying a first script associated with a functionality of a user interface element of the first set of user interface elements, the first script configured for asynchronous loading; and
a second script configured to receive a user input to the user interface element and to buffer the user input;
rendering, by the frontend application, the first set of user interface elements;
executing, by the frontend application, the second script;
receiving after the first response, a second response comprising the first script; and
executing, by the frontend application, the first script and providing, by the second script, the user input as input to the first script.

### Claim 11 (depends on 10)

The method of claim 10, wherein the user information comprises a user-agent string.

### Claim 12 (depends on 10)

The method of claim 10, wherein the response comprises hypertext markup language content.

### Claim 13 (depends on 10)

The method of claim 10, wherein the second script is smaller than the first script.

### Claim 14 (depends on 10)

The method of claim 10, wherein:
the user input is a first user input;
the user interface element is a first user interface element; and
the second script is configured to:
receive a second user input to a second user interface element and to buffer the second user input; and
provide the second user input as input to a third script after loading of the third script by the frontend application instance.

### Claim 15

A method of decreasing apparent load time of a pageload in a frontend application associated with a backend application of a software platform, the method comprising:
requesting by the frontend of the backend, the page;
receiving at the frontend from the backend, a first portion of the page the first portion comprising an input buffer script;
executing by the frontend the input buffer script;
rendering by the frontend the first portion of the page;
receiving an input from a user to the rendered first portion of the page;
buffering the input by the input buffer script;
after receiving the input, receiving at the frontend from the backend, a second portion of the page, the second portion comprising an input processing script;
executing by the frontend the input processing script;
providing, as input to the input processing script by the input buffer script, the input; and
providing by the input processing script to the backend, the input.

### Claim 16 (depends on 15)

The method of claim 15, wherein the input comprises user-input text.

### Claim 17 (depends on 15)

The method of claim 15, wherein the input comprises an interaction with a user interface element associated with the first portion of the page.

### Claim 18 (depends on 15)

The method of claim 15, wherein the input comprises a selection by the user of a reaction button.

### Claim 19 (depends on 15)

The method of claim 15, wherein the input processing script replaces inline the input buffer script.

### Claim 20 (depends on 15)

The method of claim 15, wherein the first portion of the page comprises user interface elements, interface style elements, and the input buffer script.
