I am lazy, sorry

ANG SILAKBO's design has direct embedded raw HTML into our content management system. This flexibility allows me to bypass the typical constraints of structured content editors when necessary. Rather than being limited to predefined components or blocks, I can craft pixel-perfect custom elements with precise control over both presentation and functionality. This approach has been particularly valuable for creating interactive data visualizations, custom layouts, and specialized UI components that wouldn't be possible through standard editing interfaces.

The decision to support embedded HTML wasn't made lightly, as it introduces potential security and maintenance considerations. To mitigate risks, I implemented a robust sanitization layer that carefully validates all HTML input to prevent cross-site scripting attacks while preserving legitimate functionality. Additionally, I created a comprehensive style guide and component library to encourage consistency even when using raw HTML. This balanced approach gives our content team extraordinary creative freedom while maintaining the platform's security and visual coherence.

While I could have built more sophisticated visual editors or component systems, I've found that sometimes the most efficient solution is simply allowing direct HTML input. This approach acknowledges that no pre-built system can anticipate every creative need, and sometimes the most straightforward path is to leverage the web's native language directly. As when I was about to sleep one night, I thought and asked, "Why build a complex interface to generate HTML when I already know HTML?" This pragmatic philosophy has saved countless development hours while empowering our team to create truly distinctive content experiences.

I used Firebase because I thought it is cool

My journey began with Firebase, which served me well in the early days. The realtime database and authentication solutions allowed me to move quickly and iterate on features without worrying about infrastructure. I could focus on building the core functionality that our editorial team needed, while Firebase handled the complexities of data synchronization, authentication, and hosting. This approach was perfect for my initial prototype and early beta versions, allowing me to validate ideas with minimal investment in backend development.

However, as our readership grew and the feature set expanded, I began to encounter limitations. Complex querying became a challenge, as Firebase's NoSQL structure wasn't optimized for the relational data models we increasingly needed. I found myself implementing workarounds and client-side data manipulations that added complexity to the codebase. More concerning was the cost trajectory – as usage scaled, I noticed Firebase costs growing at a rate that would eventually become unsustainable for our business model.

After careful evaluation of alternatives, I made the decision to migrate to Supabase. This wasn't merely a technical choice but represented a fundamental shift in my approach to building the platform. I was moving from a prototype mindset focused on rapid iteration to building for sustainable scale with more sophisticated data modeling and access patterns.

The migration process itself was a significant undertaking. I had to carefully map existing data structures to a relational model, design a schema that would support current needs while allowing for future growth, and implement a data migration strategy that minimized disruption to our editorial workflow. I approached this methodically, first migrating non-critical features to validate my approach before tackling core functionality.

Supabase gave me the power of PostgreSQL with Row-Level Security, enabling a level of data control and query sophistication that wasn't possible before. I could now implement complex relational queries directly in the database, reducing the amount of data processing needed in my application code. The fine-grained permissions system allowed me to implement more nuanced access controls, improving both security and performance. Stored procedures helped me encapsulate complex business logic at the database level, ensuring consistency across different parts of the application. Perhaps most exciting was gaining access to PostgreSQL's geospatial capabilities, which opened up entirely new feature possibilities for location-based content and recommendations.

The performance improvements were immediately noticeable. Query response times for complex operations improved by approximately 65%, particularly for data aggregations and joins that had previously required multiple round trips to the database. Our database costs reduced by roughly 40%, even as we continued to scale, thanks to more efficient data storage and query execution. Most importantly, I found we could handle about three times the concurrent readers with the same infrastructure, giving me confidence in our ability to grow.

Media Management Evolution

As content creation became central to our platform, I needed a more sophisticated approach to media handling. Initially, I stored images directly in the database as binary data, which was simple but created performance issues as our media library grew. I then moved to storing files on our servers with a basic directory structure, but this approach didn't scale well and lacked features like automatic resizing and optimization.

My integration with Cloudinary transformed our approach to assets. Instead of managing media files myself, I leveraged Cloudinary's specialized platform to handle the complexities of modern media management. This decision had far-reaching implications for both performance and developer productivity.

On-the-fly transformations became a game-changer for the reader experience. I could now generate appropriately sized images for different devices and contexts without storing multiple versions of each asset. A single high-resolution original could be dynamically transformed to meet any requirement – thumbnails, previews, full-screen displays – all by simply modifying URL parameters. This not only saved storage costs but dramatically improved page load times across the platform.

Automatic format selection was another significant benefit. Cloudinary's intelligent delivery system could serve images in next-generation formats like WebP to supporting browsers while falling back to more compatible formats for older clients. This optimization happened transparently, ensuring readers always received the best possible balance of quality and performance without any additional development effort on my part.

The AI-based tagging capabilities helped our editorial team build a more searchable and accessible media library. New uploads were automatically analyzed and tagged with relevant keywords, making it easier for our team to find related content. This system improved over time as it learned from our specific content patterns, becoming increasingly accurate at identifying the subjects and themes present in our media.

Responsive breakpoints addressed one of my most persistent challenges – delivering appropriately sized images across the wide variety of devices our readers employed. Rather than manually defining image sizes, I could now automatically generate optimal breakpoints based on content analysis, ensuring images looked crisp on everything from mobile phones to large desktop displays without unnecessary bandwidth usage.

Media Management Engine System LOL

One of the most complex systems I've developed is the submission engine – the critical infrastructure that handles how content is uploaded, processed, stored, and versioned within ANG SILAKBO. This system touches nearly every aspect of the platform and has evolved significantly as my understanding of our editorial needs has deepened.

The submission engine is built around a sophisticated file processing pipeline. When our team uploads content – whether it's a document, image, video, or other media – it triggers a series of automated processes designed to ensure security, extract useful information, and prepare the content for various use cases throughout the platform.

Security is my first priority in the pipeline. Every uploaded file is immediately scanned using ClamAV, an open-source antivirus engine that I've configured specifically for our content types. This step ensures that malicious files are identified and quarantined before they can enter the storage systems or be shared with readers. I've found this proactive approach to security essential as our readership has grown and the volume of uploads has increased.

Once a file passes security validation, I extract metadata using Apache Tika. This powerful tool analyzes the content and structure of files to identify information like document authors, creation dates, embedded metadata tags, and even the text content of documents. This extraction process allows me to automatically catalog and organize submissions without requiring our editorial team to manually enter this information, improving both the workflow efficiency and the quality of the content database.

For visual content, I generate appropriate thumbnails and previews to enable quick browsing without loading full-sized assets. I use Ghostscript for PDF documents, creating image previews of key pages that our editors can quickly scan. For video content, FFmpeg helps me extract representative frames and create compressed preview clips. These previews are essential for our content management interfaces, editorial review processes, and publishing workflows.

Version Control System

Perhaps the most innovative aspect of my submission engine is the git-inspired version control system I've implemented. Traditional content management systems often treat revisions as an afterthought, but I recognized early on that versioning would be central to our editorial workflows. Creative work is inherently iterative, and I wanted to support that process natively within the platform.

My version control system allows our team to track changes to content over time with a complete history of modifications. Each version is stored efficiently, with only the delta changes between versions consuming additional storage. Our editors can compare any two versions to see exactly what changed, whether it's text edits in an article, adjustments to an image, or modifications to metadata.

The ability to revert to previous states has proven invaluable for our editorial process. When experiments don't work out or mistakes are made, our team can simply roll back to a known good version rather than trying to manually undo changes. This safety net encourages creative exploration and reduces the anxiety associated with making significant changes to important content.

I've extended the git metaphor further by implementing a branching system that allows our editors to create experimental versions of content without affecting the published version. This is particularly useful for collaborative work, where team members might want to explore different approaches in parallel. Editors can work on their branches independently and then merge changes back into the main version when they're ready, complete with tools to resolve conflicts when multiple people have modified the same content.

Uhm, messaging?

Communication is at the heart of collaboration, and our messaging system has evolved into a sophisticated backbone that supports both real-time interactions and persistent historical records. Building a messaging system that could scale with the platform while maintaining performance presented unique challenges that required a multi-faceted approach.

I designed the messaging architecture around a combination of specialized technologies, each chosen to address specific aspects of the problem. WebSockets provide the foundation for real-time communication, establishing persistent connections between clients and our servers that allow for immediate message delivery. This approach dramatically reduces latency compared to traditional polling methods, creating a responsive experience that feels natural and immediate for our team.

For message storage and retrieval, I selected Apache Cassandra after evaluating several alternatives. Cassandra's distributed architecture proved to be an excellent fit for our messaging workload for several reasons. Its linear scalability model means I can add new nodes to the cluster as message volume grows, without complex rebalancing operations or performance degradation. This horizontal scaling approach aligns perfectly with our growth trajectory.

High availability was another critical factor in my choice of Cassandra. With no single point of failure in the architecture, I've been able to achieve 99.99% uptime for messaging services, even during maintenance operations and occasional hardware failures. The system's ability to gracefully handle node outages ensures that conversations continue uninterrupted even when parts of our infrastructure are being updated or experiencing issues.

Perhaps most importantly, Cassandra's data model is exceptionally well-suited for time-series data like message histories. Its optimized write path and efficient storage of time-ordered data allow me to maintain sub-50ms response times even when retrieving conversation histories spanning months or years. This performance characteristic is essential for providing a seamless experience when our team scrolls through previous messages or searches for specific content in their conversations.

Redis complements our architecture by providing presence tracking and ephemeral state management. It allows me to efficiently track which team members are online, who is currently typing in a conversation, and other transient states that enhance the interactive feel of the platform. The in-memory nature of Redis makes these operations extremely fast, while its persistence options ensure I don't lose critical state information during system restarts.

CoralVIA ISTG TS PMO

One of the most exciting aspects of my work on ANG SILAKBO has been integrating artificial intelligence capabilities throughout the platform. I've been developing a suite of AI-powered tools that enhance our content creation, analysis, and management workflows. These tools are designed to augment our team's creative abilities rather than replace them, providing insights and automating routine tasks to free up more time for meaningful work.