Short Answer
Based on our team’s experience, PHP offered the best route for Yield Monitor to create an efficient, scalable, standalone processing and indexing infrastructure upon which we could build data-driven tooling for developers and investors.
Share With Friends
Note: this article contains high-level context about why Yield Monitor has chosen to build in PHP. Keep in mind that each project, their needs, goals, and use cases vary and the topics below range, widely, depending on the context of each project and several nuanced factors.
Introduction
Infrastructure has continued to dominate many conversations across DeFi and blockchain as a whole, with many excellent perspectives around languages, tech stacks, and optimization strategies.
Generally speaking, leading infrastructure products focus on offering fast, enterprise-grade node and data services to teams and solo developers — with much success. They created a foundational layer of accessibility and empowerment for those entering Web3 with a desire to build and deploy data-driven products.
As blockchain services and sectors like DeFi, GameFi, NFTs, and others continue to expand, the need to supplement nodes with faster indexing services has become increasingly paramount. Looking beyond node-as-a-service models, we have to build tools that give developers and teams the gold nuggets at wholesale; not just sharper picks and wider shovels.
Why It Matters
As blockchains continue to grow, the data stored within them increases exponentially. While node-as-a-service organizations will remain paramount to the growth of Web3, additional services like Yield Monitor add value to teams managing nodes, but require faster data indexing, distillation, and parsing in queryable formats.
This is especially important to solo builders and small teams who may not have experienced engineers or the budgets to hire them. We need to ensure market all participants get the data they need, when they want it, in highly scalable ways — deliverable data that:
- isn’t cost prohibitive
- is Web2 developer friendly
- written in accessible language
- available for any application
- is powered by highly scalable back-end infra
This isn’t just a business model — it’s a pillar of decentralization and accessibility.
The Ethos of Yield Monitor
We feel strongly that access to on-chain data and asset computation belongs to everyone. Solo developers and small teams shouldn’t be burdened with high costs or technical barriers to get the data they need to build amazing products. Additionally, DeFi users and investors need tools that aggregate significant amounts of data in reliable ways at scale.
As a small team, building the tools we want to provide requires us to build according to this mindset. At present, Yield Monitor processes transaction and price data across seven mainnets, hundreds of protocols, covering many thousands of liquidity pools and single assets.
We simply could not do this using the traditional node-as-a-service model. The costs alone would be astronomical and unsustainable. We had to create our own infrastructure to support our goals, and we’re motivated by the validation we’ve continued to see from builders and users.
More efficient infrastructure means powerful products, profitable portfolios, and a happier and more active class of market participants.
Significantly more data can be provided to multiple teams and users via single processes that would otherwise be done on a per-need basis. This is massively inefficient and, as blockchains grow, will become increasingly cost prohibitive.
We’ve built an efficient, scalable infrastructure that can make a difference.
To each, their own.
While this article explains our rationale for our on tech stack, we understand a single solution doesn’t work for everyone. We admire, appreciate, and support all builders and organizations, their own stacks, and their own opinions about the pros and cons of various programming languages. We support diversity of opinion and put no effort or value in attacking or criticizing others’ preferences.
Building Accessible Tooling that Scales
For us, the decision to build infrastructure in PHP, Symfony, and MySQL makes the most sense given our team’s technical background and experience.
To reinforce the advantages of PHP, and to accommodate the unique requirements of blockchain and DeFi tooling, we’ve created parallel multi-threaded systems give us the ability to index high amounts of data with background tasks running constantly to ensure aggregation and computation remain efficient.
Let’s highlight more of our rationale regarding PHP.
Wide Adoption:
PHP is one of the most widely adopted programming languages for web development. It powers a significant portion of the internet, including popular websites like Facebook, WordPress, and Wikipedia. Its widespread usage has led to the development of a vast ecosystem of libraries, frameworks, and tools, making it easier to build scalable applications.
To boost our utility, Yield Monitor has created crypto-specific infra to compound PHP’s utility while helping us meet the needs of DeFi-specific applications.
Mature Frameworks:
PHP has mature and robust frameworks like Laravel and Symfony, which provide a solid foundation for building scalable applications. These frameworks offer features like database abstraction layers, caching mechanisms, queuing systems, and routing systems, making it easier to handle scalability challenges.
Yield Monitor leverages AWS for its own query systems.
Performance:
PHP has made significant performance improvements in recent years. The introduction of PHP 7 brought substantial speed improvements, making PHP more efficient and capable of handling larger workloads.
While there are faster languages, our team’s experience with PHP made this the best choice for our own product vision. We’ve created additional internal systems to regain ground with regards to efficiency in the context of PHP performance.
Caching and Optimization:
PHP has various caching mechanisms and optimization techniques available. Caching tools like Memcached or Redis can be used to store frequently accessed data in memory, reducing the load on the database and improving response times. Additionally, PHP provides opcode caching, which caches the compiled bytecode of PHP scripts, eliminating the need for repetitive parsing and compilation.
Scalable Infrastructure:
PHP applications can be deployed on a variety of scalable infrastructure options, such as cloud platforms like Amazon Web Services (AWS), Microsoft Azure, or Google Cloud. These platforms offer auto-scaling features, allowing applications to automatically adapt to increased traffic by adding more resources when needed.
In this context, Yield Monitor leverages scaling solutions via AWS.
Support for Multiple Databases:
PHP has extensive support for multiple databases, including MySQL, PostgreSQL, Oracle, MongoDB, and more. This flexibility enables developers to choose the most suitable database solution for their scalability needs and handle large datasets efficiently — perfect for blockchains, DeFi computation, transaction history, etc.
Yield Monitor leverages MySQL to index data, which aligns with our team’s experience.
Community Support:
PHP has a large community of developers who contribute to its growth and offer support through forums, online resources, and open-source projects. This community-driven nature ensures that PHP continues to evolve, addressing scalability challenges and offering solutions based on real-world experiences. There’s a reason why industry leaders and their engineers choose to build on PHP.
We hope that Yield Monitor can become a community resource for PHP developers interested in building in blockchain and crypto-related ecosystems.
Keep In Mind
We understand and appreciate that a developer or team’s needs are unique to their own goals and use case. Various factors like architecture, design choices, optimization techniques, and infrastructure setup impact the decision making process. For Yield Monitor, PHP was a clear route forward with regards to our team’s experience, our infrastructure requirements, and expanding set of DeFi tooling.
Potential Obstacles of PHP
Inconsistent Syntax:
PHP’s syntax can be inconsistent and confusing at times. Over the years, the language has evolved, leading to variations in function names, parameter order, and naming conventions. This inconsistency can make it challenging for developers to switch between different PHP projects or libraries.
The release of PHP 7, however, made drastic improvements to these issues.
Weak Typing:
Many argue that PHP is a weakly typed language, which means that variables do not have strict data types. While this flexibility can be convenient for quick prototyping or small projects, it can lead to unexpected behavior and bugs in larger and more complex applications. It requires careful handling of variable types to ensure data integrity and prevent errors.
The release of PHP 7, however, made drastic improvements to these issues.
Performance Considerations:
Although PHP has made significant performance improvements in recent years, it may still be slower compared to some other programming languages like Go or Java. PHP’s dynamic nature and interpretation at runtime can introduce overhead, especially when handling large-scale applications with heavy computational tasks. However, with proper optimization techniques and caching mechanisms, performance can be significantly improved.
Yield Monitor has built additional infrastructure to address this potential issue; with massive amounts of workers running computation in parallel. Our complex queue system can scale in any direction.
Limited Multithreading:
Historically, PHP follows a shared-nothing architecture, where each HTTP request is handled by a separate process. This approach simplifies development but limits the ability to efficiently handle concurrent tasks and parallel processing. While extensions and workarounds exist to introduce some level of multithreading, it is not as native or straightforward as in languages specifically designed for concurrent processing.
Yield Monitor has addressed this head-on, with a customized, multi-threaded worker system that removes these concerns. This allows us to index transactional data highly efficiently.
Scalability Challenges:
Although PHP can be scalable, building highly scalable PHP applications requires careful consideration, proper architecture, and experienced engineers. Scaling PHP applications across multiple servers can be more complex compared to languages like Node.js or Golang, which have built-in support for non-blocking I/O and event-driven architectures. However, with the use of caching, load balancing, and optimized database queries, PHP can still achieve good scalability.
Is PHP a Strong Choice for Blockchain Indexing?
With additional engineering and optimizations, using PHP for blockchain indexing can be a viable option depending on the specific requirements and context of your project. For Yield Monitor, it was the best option based on our goals, our founding team’s experience, and our ability to make strategic operational enhancements when required.
Here are some factors to consider if you’re building infrastructure in Web3:
Blockchain Technology:
PHP is a server-side scripting language commonly used for web development. If you intend to index a blockchain that offers an API or other interfaces for data retrieval and analysis, PHP can be used effectively to consume and process that data. However, if you plan to interact directly with the blockchain’s underlying protocol or require low-level access to blockchain data, you may need to consider languages more suited for that purpose, such as Go or Python.
Since Yield Monitor has entirely standalone infrastructure, PHP makes the most sense based on our own needs and existing team experience. This allows us to build an extremely high powered foundation, and scalable runway to create value leveraging this stack.
Performance Considerations:
Blockchain indexing typically involves processing a large volume of data and performing computationally intensive operations. While PHP has made performance improvements, it may not be as performant as some other languages like Go or C++ for handling such tasks. If indexing speed and efficiency are crucial for your project, you might want to consider languages that are better optimized for high-performance computing.
Yield Monitor has built separate supportive infrastructure to mitigate this issue — computation and distillation of data is run in parallel and different blocks can be processed at the same time. Subsequently, our indexing is not impacted by this need.
Scalability:
Blockchain indexing often involves processing and storing large amounts of data. PHP can scale horizontally by distributing the load across multiple servers, but it might require additional infrastructure setup and careful consideration of caching, load balancing, and database optimization techniques to ensure scalability. If your project requires significant scalability and performance, you may want to evaluate other languages or technologies that are specifically designed for handling distributed systems and parallel processing.
Yield Monitor has addressed this need head-on; building dedicated infrastructure to support and enhance scalability to avoid limitations.
Team Expertise:
Consider the skill set and familiarity of your development team. If your team has extensive experience and expertise in PHP, it can be a reasonable choice for blockchain indexing, especially if the project involves web-based interfaces and data presentation. However, if your team has more experience with other languages that are commonly used in the blockchain space, it might be worth considering those options to leverage their expertise.
Comparing PHP to Javascript
Many teams are leveraging JavaScript (JS) to clone existing projects and/or build their own products that integrate various services and part of their overall offering. PHP and JS are both popular languages, but they have different strengths and characteristics when it comes to data handling and indexing. Here’s some context to why we chose PHP over JS:
We Built Our Own Solution:
This one’s simple — our team is highly experienced in PHP and we wanted to create our own, standalone infrastructure based on our long-term vision.
Server-Side vs. Client-Side:
PHP is primarily used on the server-side, executing on the server to generate HTML and process data before sending it to the client. In contrast, JS is a client-side language that runs in the browser, allowing for interactive and dynamic web experiences. When it comes to data handling and indexing, PHP is often used on the server to process and serve data, while JS can be used to manipulate and display data on the client-side.
This is a core issue that Yield Monitor addresses. Accessible data and the ability to create scalable user tools means PHP is a better choice, in our opinion, than JS. As Web3 and, in our case, DeFi continues to onboard users at global scale, PHP applications will have more success in serving users the data they need, faster. In parts of the world where bandwidth is finite, we fear JS will create poor user experiences, or cause the application to fail on the user side due to bandwidth limitations.
Database Interactions:
PHP has extensive support for various databases, making it well-suited for interacting with databases and performing data indexing tasks. It provides database abstraction layers, query builders, and libraries specific to different database systems. JS, on the other hand, can interact with databases on the client-side through APIs like IndexedDB or by making requests to server-side APIs written in languages like PHP. However, it’s important to note that direct database access from client-side JS is generally discouraged due to security reasons.
Backend Processing:
PHP is often used for server-side scripting and backend processing, including data retrieval, manipulation, and indexing. It provides features like file handling, string manipulation, regular expressions, and database operations, which can be useful for processing and indexing large amounts of data. JS, primarily being a client-side language, can perform some data processing and manipulation tasks on the client-side, but it may have limitations when it comes to large-scale indexing operations.
Asynchronous Processing:
JavaScript, particularly with the introduction of asynchronous programming patterns and the Promise/async/await syntax, is well-suited for handling asynchronous operations. This is especially useful when making API calls or performing non-blocking I/O operations, which can be leveraged for data indexing tasks.
PHP traditionally follows a synchronous execution model, although recent versions have introduced some asynchronous capabilities. However, PHP might require additional libraries or extensions to achieve similar levels of asynchronous processing as JS.
Ecosystem and Libraries:
Both PHP and JS have extensive ecosystems and libraries available. PHP has a wide range of libraries and frameworks specifically designed for backend development, database interactions, and data processing, including frameworks like Laravel and Symfony. JS, on the other hand, has a rich ecosystem of frontend libraries and frameworks like React, Angular, and Vue.js, which can be used to build interactive data visualizations and perform client-side data manipulations.
TL;DR
In summary, PHP is often used for server-side scripting, backend processing, and database interactions, making it suitable for data indexing tasks on the server. JS, being a client-side language, can handle data manipulation and display on the client-side, but it may have limitations when it comes to large-scale data indexing.
The choice between PHP and JS for data indexing ultimately depends on factors such as the specific requirements of your project, the type of data processing needed, and whether the indexing is better suited for server-side or client-side execution.
PHP has many beneficial aspects that, for Yield Monitor specifically, make it the stronger choice for long-term scalability and data deliverability.
Conclusion
Yield Monitor’s decision to build customized infrastructure on PHP has been driven by our team’s extensive experience and our unwavering commitment to creating scalable, efficient, and sustainable technology infrastructure.
Our choice positions us uniquely to deliver robust data indexing and processing services, with impressive speed and a high degree of cost-effectiveness. Additionally, the high degree of focus we’ve placed on our PHP foundation provides a flexible framework upon which many useful, profitable, investor-driven tools can be built.
As we consider the coming years in the context of DeFi, we see our solutions not merely as a suite of services, but as blueprints for responsible, eco-friendly data management in the DeFi space and, more broadly, digital asset verticals as a whole.
