The document discusses performance optimization in API projects, emphasizing the importance of understanding database queries, object serialization, and algorithmic complexity. It offers solutions for improving efficiency through different fetching strategies in ORM, using well-defined queries, and minimizing data hydration. Key points include balancing the amount of data fetched and hydrated to achieve optimal performance for applications.

1. Need for Speed
Removing speed bumps in API Projects

2. Introduction

3. Weavers, Sylius, API Platform

4. Why do we need to thinks
about performance?

5. ~ Amazon
“100ms Faster
=
1% More Revenue.”

7. How?

8. Let’s start!

9. The most common performance bottlenecks
0
15
30
45
60
Amount of queries to DB Cost of object serialization Latency Framework
5
4
28
56
Votes

10. Base

11. Algorithmic complexity

12. O(M) vs O(MN) vs O(M^2)

14. That’s why we usually forget
about it :/

15. Measure!

16. Understanding of tools

17. Tools are generally performant
But Your case is different

18. Project structure

20. Database turn

21. N+1

22. Product list

23. Let’s start small
{
"@context":"/api/contexts/Product",
"@id":"/api/products",
"@type":"hydra:Collection",
"hydra:totalItems":6,
"hydra:member":[
{
"@id":"/api/products/1",
"@type":"Product",
"id":1,
"name":"T-Shirt",
"price":1000
},
{
"@id":"/api/products/2",
"@type":"Product",
"id":2,
"name":"Trousers",
"price":5000
},
{
"“…“":"“…“"
}
]
}
Amount of products: 6
No associations between objects
Sample query on the left

25. O(1)

26. Order list

27. How many queries are executed here?
{
"@context": "/api/contexts/Order",
"@id": "/api/orders",
"@type": "hydra:Collection",
"hydra:totalItems": 3,
"hydra:member": [
{
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
"/api/order_items/1",
"/api/order_items/2"
]
},
{
“…”: “…“
}
]
}
Amount of orders: 3
Every order associated with 2 items
Sample query on the left
No total
fi
eld

30. O(M)

31. Order list with additional
fi
eld

32. How many queries are executed here?
{
"@context": "/api/contexts/Order",
"@id": "/api/orders",
"@type": "hydra:Collection",
"hydra:totalItems": 3,
"hydra:member": [
{
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
"/api/order_items/1",
"/api/order_items/2"
],
"total": 7000
},
{
“…”: “…“
}
]
}
Amount of orders: 3
Every order associated with 2 items
Sample query on the left
Added “total()” as a function of product
price and quantity of item

34. O(M*N) or O(M^2) 🚀

36. How to spot it?

38. How to
fi
x it?

39. Solution 1

40. #[ORMOneToMany(fetch: ‘LAZY')]
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')]
#[ORMOneToMany(fetch: ‘EAGER')]
What is the difference between them?

41. #[ORMOneToMany(fetch: ‘LAZY')] => 11
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')] => ???
#[ORMOneToMany(fetch: ‘EAGER')] => ???

42. #[ORMOneToMany(fetch: ‘LAZY')] => 11
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')] => 11
#[ORMOneToMany(fetch: ‘EAGER')] => ???

43. #[ORMOneToMany(fetch: ‘LAZY')] => 11
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')] => 11
#[ORMOneToMany(fetch: ‘EAGER')] => 9

45. #[ORMOneToMany(fetch: ‘LAZY')] => 11
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')] => 11
#[ORMOneToMany(fetch: ‘EAGER')] => 9
#[ORMOneToMany(fetch: ‘EAGER')] => 5 (OrderItem and Product)

47. #[ORMOneToMany(fetch: ‘LAZY')] => 11
#[ORMOneToMany(fetch: ‘EXTRA_LAZY')] => 11
#[ORMOneToMany(fetch: ‘EAGER')] => 5
#[ORMOneToMany(fetch: ‘EAGER')] (OrderItem and Product) + Serialisation groups => 4

49. Solution 2

50. final class LoadItemsAndProductsExtension implements QueryCollectionExtensionInterface,
QueryItemExtensionInterface
{
private function apply(QueryBuilder $queryBuilder): void
{
$queryBuilder
->addSelect('oi', 'p')
->join(OrderItem::class, 'oi', Join::WITH, 'oi.originOrder = o')
->join(Product::class, 'p', Join::WITH, 'oi.product = p')
;
}
}

52. But….

53. {
"@context": "/api/contexts/Order",
"@id": "/api/orders",
"@type": "hydra:Collection",
"hydra:totalItems": 3,
"hydra:member": [
{
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
"/api/order_items/1",
"/api/order_items/2"
],
"total": 7000
},
{
"@id": "/api/order_items/1",
"@type": "OrderItem",
"id": 1,
"product": "/api/products/1",
"quantity": 2,
"originOrder": "/api/orders/1",
"price": 2000
},
{
"@id": "/api/products/1",
"@type": "Product",
"id": 1,
"name": "T-Shirt",
"price": 1000
},
{
"@id": "/api/order_items/2",
"@type": "OrderItem",
"id": 2,
"product": "/api/products/2",
"quantity": 1,
"originOrder": "/api/orders/1",
"price": 5000
},
{
“…”: “…”
}
]
}

54. Solution 3

55. class OrderCollectionProvider implements ProviderInterface
{
public function __construct(private readonly OrderRepository $orderRepository)
{
}
public function provide(
Operation $operation,
array $uriVariables = [],
array $context = []
): object|array|null {
return $this->orderRepository->findWithItemsAndProducts();
}
}

56. public function findWithItemsAndProducts()
{
return $this->createQueryBuilder('o')
->addSelect('oi', 'p')
->leftJoin('o.orderItems', 'oi')
->leftJoin('oi.product', 'p')
->getQuery()
->getResult();
}

58. But….

59. So is single query an ultimate
solution?

60. ⚠ Not so fast ⚠

61. Joins are expensive 💰

62. Hydration 🧙

63. Fetch
[
'id' => 1,
'name' => 'T-Shirt',
'price' => '1000'
]
Hydration 🧙
new Product()
Database Application

64. More data you fetch
||
/
More you hydrate

65. Perfect size of micro service?

66. Perfect amount of queries?

67. Fetch as much as you have to
But not more

68. Proper de
fi
nition of
fi
elds

69. Float vs double

70. Decimal ->
fi
xed-point precision
Float ->
fl
oating-point precision

71. How many updates are executed?
Product has a
fl
oat price
fi
eld de
fi
ned as
fl
oat
Order item quantity has been changed by 1
During which we will read data from Product

72. How many updates are executed?

73. How many updates are executed?
Product has a
fl
oat price
fi
eld de
fi
ned as decimal
Order item quantity has been changed by 1
During which we will read data from Product

74. How many updates are executed?

75. How many updates are executed?

76. Know your tool!

77. Custom cars APIs are the
fastest

78. Serialisation twists

79. We are reducing network
connections on expanse of object
size/db connections 🤨

80. Atomic objects (Edge Side API)

81. {
"@context": "/api/contexts/Order",
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
{
"@id": "/api/order_items/1",
"@type": "OrderItem",
"product": "/api/products/1",
"quantity": 4
},
{
"@id": "/api/order_items/2",
"@type": "OrderItem",
"product": "/api/products/2",
"quantity": 1
}
],
"total": 9000
}
{
"@context": "/api/contexts/Order",
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
{
"@id": "/api/order_items/1",
"@type": "OrderItem",
"product": {
"@id": "/api/products/1",
"@type": "Product",
"name": "test2",
"price": 1000
},
"quantity": 4
},
{
"@id": "/api/order_items/2",
"@type": "OrderItem",
"product": {
"@id": "/api/products/2",
"@type": "Product",
"name": "Trousers",
"price": 5000
},
"quantity": 1
}
],
"total": 9000
}

82. Atomic objects (Edge Side API)
Partial serialisation

83. {
"@context": "/api/contexts/Order",
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
{
"@id": "/api/order_items/1",
"@type": "OrderItem",
"product": "/api/products/1",
"quantity": 4
},
{
"@id": "/api/order_items/2",
"@type": "OrderItem",
"product": "/api/products/2",
"quantity": 1
}
],
"total": 9000
}
{
"@context": "/api/contexts/Order",
"@id": "/api/orders/1",
"@type": "Order",
"id": 1,
"orderItems": [
{
"@id": "/api/order_items/1",
"@type": "OrderItem",
"product": {
"@id": "/api/products/1",
"@type": "Product",
"name": "test2",
"price": 1000
},
"quantity": 4
},
{
"@id": "/api/order_items/2",
"@type": "OrderItem",
"product": {
"@id": "/api/products/2",
"@type": "Product",
"name": "Trousers",
"price": 5000
},
"quantity": 1
}
],
"total": 9000
}

84. Atomic objects (Edge Side API)
Partial serialisation
Spare
fi
elds

85. Straight of good
design

86. Huge objects are problem

87. Different representations

88. Minimising unnecessary
operations

89. Read model
shortcut

90. Saving data to different models

91. PUT REQUEST

92. Pre-computing

95. Sylius order

96. Sylius order

98. Saving serialised objects

99. Read models doesn’t have to
be models 🤯

100. 1. Store read models in key-value storage
2. Restore it by indexed key

101. Summary

103. Remember about algorithmic complexity of your queries
Do not hydrate too much data
Think about the box of your “entities”

104. Thank you!