Serverless Analytics with Real-time Security & AI Insights

---

Full Score is a lightweight (3KB gzip) library, providing serverless event analytics with real-time security monitoring and AI insights. Based on the Semantic Raw Format (SRF), it implements an efficient architecture that enables AI to analyze user journeys directly without semantic parsing.

This site showcases Full Score’s live performance. The journey appearing at the bottom is in the same form as the interaction data actually analyzed by Edge. It flows naturally, like music in resonance.

Here are the orchestrated capabilities. Click to explore each movement.

1. 🧭 Serverless Analytics with No API Endpoints & 90% Cost Reduction
2. 🔍 Complete Cross-tab User Journey Without Session Replay
3. 🧩 Bot Security & Human Personalization via Real-time Event Layer
4. 🧠 BEAT Flows into AI Insights as Linear Strings, No Semantic Parsing
5. 🛡️ GDPR-Conscious Architecture with Zero Direct Identifiers

All while achieving a decentralized paradigm using browsers as auxiliary databases.

This demo focuses on live performance, offering a quick and intuitive overview. If it resonates with you, please refer to the 🔗 GitHub README and code comments for full technical details.

---

1. Serverless Analytics with No API Endpoints & 90% Cost Reduction

Traditional analytics platforms built for web traffic analysis, session replay, and cohort tracking excel at their tasks. However, gaining user insights typically requires heavy and complex infrastructure.

They rely on bulky data formats such as JSON events and DOM snapshots, all transmitted to centralized servers for storage and processing. This results in script payloads of tens of kilobytes, millions of network requests, and monthly infrastructure costs in the thousands.

Full Score doesn't try to solve this complexity. It removes it entirely, proposing a new paradigm.

• Traditional Analytics
  Browser → API → Raw Database → Queue (Kafka) → Processing (Spark) → Processed Database → Archive
  ⛔ 7 Steps, $1,000 – $5,000/month
  

  ---

• Full Score
  Browser ~ Edge → Archive
  ✅ 2 Steps, $50 – $500/month

  // No API endpoints needed
  // No queues or processing needed
  // No Origin access required
  

It begins with a simple realization. Gaining insight into a user's complete browsing journey doesn't always require transmitting data elsewhere.

Every browser already provides storage like first-party cookies and localStorage. What if insights were recorded there first, and interpreted only once, at the moment a user's browser performance is deemed complete?

By turning each browser into infrastructure, the need for complex, centralized systems disappears. A billion users become like a billion decentralized databases, each holding their own raw data.

Of course, few would have embraced this approach because data transmission protocols are extremely limited. JSON events and DOM snapshots are too heavy, so even sending data once still requires Queue and Processing layers.

That’s why Full Score utilizes BEAT, a new data format. BEAT has lower structural overhead than JSON, so it is lighter and requires no queues or processing. By recording event sequences as linear strings, raw data becomes music, naturally readable to both humans and AI.

And the resonance with Edge computing completes the story.

As the video shows, Edge transforms Full Score into a real-time analytics layer with no API endpoints required. Edge reads the request headers from each browser.

No Origin access is required. The performance completes through the natural resonance between browser and Edge, fast, vivid, and self-contained. Processing delays are imperceptibly low.

Because browser and Edge are so close in space and time, their connection resembles resonance more than transmission, like listening to music flowing through the air.

For sites spending $1,000–5,000/month on analytics, Full Score typically runs at around $50/month for Edge computing and cloud archiving combined. With AI insights preprocessing at the Edge, costs can scale up to roughly $500/month. This is a conservative estimate and actual costs may vary depending on your environment. Its decentralized, Edge-based design keeps costs stable as traffic scales.

Full Score uses a different data structure and flow than traditional approaches, making it a powerful partner rather than a full replacement for existing analytics or security layers. It works most effectively alongside platforms such as Edge analytics and WAF.

---

2. Complete Cross-tab User Journey Without Session Replay

Traditional analytics makes cross-tab analysis complex and incomplete. It requires a complicated pipeline including identifier collection, sessionization, data ingestion, joins, post-processing, and real-time synchronization.

Full Score treats browsers as auxiliary databases, so complete journeys including cross-tab navigation are recorded immediately. With a single prompt, AI can interpret this data directly, eliminating the entire pipeline of identifier collection, sessionization, data ingestion, joins, post-processing, and real-time synchronization.

Click the button below to open a new tab and test it yourself.

Open new tab

In the demo's RHYTHM data, you can see tab navigation in the (@---N) format.

Full Score uses up to 7 cookies by default. When an 8th tab opens, existing data is automatically archived and a new set begins. All sessions are batched together at the same moment as one complete snapshot.

Even if batching occurs more than once due to specific conditions, all sessions share the same timestamp and hash, allowing the entire journey to be reconstructed as a single continuous sequence.

However, opening 8+ tabs simultaneously is rare. This likely indicates abnormal bot behavior patterns.

Full Score elegantly addresses this challenge. 🔗 When resonating with Edge, it enables real-time security and personalization.

---

3. Bot Security & Human Personalization via Real-time Event Layer

Let's start with a simple test. Tap the button below either at bot pace (rapid, mechanical taps) or at human pace (imperfect, natural taps).

This test may briefly trigger a Managed Challenge that clears in about 30 seconds.

Are you human?

See how the movement field changes from (0000000000) to (1000000000), (2000000000), or (0100000000), (0200000000)? That’s Full Score working with Edge to analyze behavior in real time.

Traditional bot detection relies on IP blocking, CAPTCHAs, and fingerprinting. But smart bots bypass these. Full Score takes a different approach, watching behavior patterns to catch bots that try to act human but give themselves away through unnatural actions like clicking without scrolling.

For real users, this provides personalized user experiences. Someone clicks add to cart three times quickly? Show them a help message. Someone spends a long time browsing? Show them a discount.

In the next section, the AI-readable characteristics of BEAT are introduced. But as the examples so far have shown, the event data expressed through BEAT already has clear practical value on its own. Using Full Score solely for real-time security and personalization is also a valid choice.

---

4. BEAT Flows into AI Insights as Linear Strings, No Semantic Parsing

BEAT (Behavioral Event Analytics Transcript) is a core structure for multi-dimensional event data, including the space where events occur, the time when actions occur, and the depth of each action, in linear sequences. These sequences express meaning without parsing (Semantic), preserve information in their original state (Raw), and maintain a fully organized structure (Format). Therefore, BEAT is the Semantic Raw Format (SRF) standard.

🔗 For detailed explanations of the BEAT format, see the GitHub README.

• rhythm_1=2___1_5_32_8_12047_!home~237*nav-2~1908*nav-3~375/123*help~1128*more-1~43!prod~1034*button-12~1050*p1@---2~54*mycart@---3
• rhythm_2=2___1_1_24_7_11993_!p1~2403*img-1~1194*buy-1~13/8/8*buy-1-up~532*review~14!review~1923*nav-1@---1
• rhythm_3=2___1_1_0_0_12052_!cart

In the Edge, BEAT sequences can be serialized as NDJSON so each journey stays on a single line. This keeps logs compact, makes querying simple, and improves AI processing efficiency. Across Web, Mobile, IoT, Game, Finance and other event-driven systems, BEAT's semantically complete structure allows fast merging and easy compatibility with their respective formats.

BEAT is not meant to replace formats like JSON, but it has the potential to move forward alongside them in a complementary way.

• {"device":1,"referrer":5,"scrolls":56,"clicks":15,"duration":1205.2,"beat":"!home ~23.7 *nav-2 ~190.8 *nav-3 ~37.5/12.3 *help ~112.8 *more-1 ~4.3 !prod ~103.4 *button-12 ~105.0 *p1 @---2 !p1 ~240.3 *img-1 ~119.4 *buy-1 ~1.3/0.8/0.8 *buy-1-up ~53.2 *review ~14 !review ~192.3 *nav-1 @---1 ~5.4 *mycart @---3 !cart"}

  Human Interpretation
  "Let's see... homepage to cart, but no purchase. What went wrong? This user really took time with the reviews."

  AI Interpretation
  [CONTEXT] Mobile user, Mapped(5) visit, 56 scrolls, 15 clicks, 1205.2 seconds
  [SUMMARY] Confused behavior. Landed on homepage, hesitated in help section with repeated clicks at 37 and 12 second intervals. Moved to product page, opened details in a new tab, viewed images for about 240 seconds. Tapped buy button three times at 1.3, 0.8, and 0.8 second intervals. Returned to the first tab and opened cart shortly after, but didn’t proceed to checkout.
  [ISSUE] Cart reached but purchase not completed. Repeated buy actions may reflect either intentional multi-item additions or friction in option selection. Long delay before checkout suggests uncertainty.
  [ACTION] Evaluate if repeated buy or cart actions represent deliberate comparison behavior or checkout friction. If friction is likely, simplify option handling and highlight key product details earlier in the flow.

Traditional data formats, including JSON, are like dots. They're great for organizing and separating individual events, but understanding what story they tell requires parsing and interpretation.

BEAT is like a line. It's the same raw data level as JSON, but because the user journey flows like music, the story becomes clear right away.

So BEAT is raw data, but it's also self-contained. No semantic parsing needed. This sounds grand, but it's really not. The BEAT expressive system is inspired by the most common data format in the world. The oldest data format in human history. Natural language.

And AI is the expert at understanding natural language.

Data resonating from Full Score to Edge becomes real-time insight reports through lightweight AI (e.g., GPT OSS 20B-class models). These reports are then archived to storage platforms such as GitHub, organized by date.

All this accumulated data flows to your AI assistant. This creates an AI-to-AI collaboration system where lightweight AI creates reports for each run or session and advanced AI synthesizes comprehensive insights from all reports. Dashboards are optional, and humans are not required to manually analyze them. Over time, models may become strong enough that this entire flow finishes in one pass, with no explicit AI-to-AI collaboration step at all. As AI evolves, systems built on BEAT evolve with it.

Start a conversation.

“Which user journey patterns are driving conversions?”
“Any notable ISSUEs today?”
“Can you suggest UX improvements?”

---

5. GDPR-Conscious Architecture with Zero Direct Identifiers

Full Score's primary implementation uses first-party cookies as its data storage. While a localStorage version exists, cookies offer a functional advantage since they're automatically included in HTTP request headers. This allows Edge to read them immediately.

First-party cookies are fundamentally different from the third-party tracking cookies commonly flagged in analytics. Full Score stores data only in users' browsers and resonates naturally with Edge without API endpoints, actually reducing exposure compared to traditional analytics approaches.

Only simple patterns are recorded, not sensitive personal information (PII), eliminating data leakage risks. As resonance occurs directly between browser and Edge without origin server involvement, interception becomes significantly more difficult. As long as the site itself has not been compromised by XSS or similar injection attacks, exfiltrating Full Score’s decentralized data at scale would require attacking users’ browsers individually, an attack vector that is realistically very difficult to execute.

For detailed GDPR and ePD compliance guidance, see the FAQ section below.

---

FAQ

Q1. Why does Full Score use the term "resonance"? Isn't HTTP header transmission still transmission?

A. Understanding this requires looking at data ownership. Here's an illustration to explain.

The first image shows traditional transmission. The two sides are completely isolated from each other. For B to hear A's performance, protocol transmission becomes inevitable. During this process, data ownership shifts from A to B and gets stored on the server. Without storing it, there's simply no way for B to hear A's performance.

The second image shows resonance between Full Score and Edge. There's still a wall between them that can't be physically crossed, but B can listen to A's performance in real time. Throughout this entire process, data ownership stays with A.

This is exactly what Edge computing enables as a serverless architecture. Edge doesn't need to receive and store data like a traditional server does. Instead, it interprets and responds immediately at the network layer closest to users. Put simply, Full Score creates a structure where data ownership remains with the user (browser) while enabling near-instant interaction.

That's why Full Score chose "resonance" as its musical metaphor. Rather than focusing on physical mechanics, it centers on the logical architecture shown above.

 

 

Q2. Do I need cookie consent for GDPR and ePD compliance?

A. This is a topic that requires legal consultation depending on jurisdiction and site policies. Please understand that this answer is based on personal experience and judgment.

The answer depends not on Full Score itself, but on the custom configuration of Edge that resonates with it.

GDPR requires legal grounds when collecting or processing identifiable personal data. The ePD requires user consent when storing information in or accessing browser storage, including cookies. However, it recognizes an exception called "strictly necessary" for cookies that are strictly required for functionality.

As explained earlier, Full Score uses first-party cookies where data ownership stays with the user (browser), fundamentally different from third-party cookies. When combined with Edge, it operates as a security and personalization layer at the serverless level.

Therefore, if Edge maintains data ownership with the user (browser) without even keeping logs, this approaches the green zone. Full Score doesn’t collect identifiable personal data covered by GDPR, while meeting the ePD's strictly necessary cookie criteria.

However, if the Edge configuration sets (LOG: true) to collect and process event data for analysis, this decision should be made carefully.

Full Score is designed to maintain complete anonymization without any personally identifiable information (PII). However, GDPR covers not only direct identification but also data with potential for indirect identification. When matched with other Edge records like IP addresses or User-Agent strings, some level of identification potential may exist.

That's why Edge includes options to remove timestamp and hash records before logging. This way, even when matched with other Edge records, indirect identification potential effectively disappears. This puts it in a gray zone closer to green.

Keeping the hash enabled remains in the gray zone, but enabling timestamps may enter the red zone and warrants legal consultation.

However, these Gray Zone and Red Zone classifications are based on a very conservative assessment. When Edge is configured to disable logging of IP addresses and User-Agent strings, there is virtually no remaining method to indirectly identify an individual.

 

 

Q3. What does BEAT mean by the Semantic Raw Format (SRF)?

A. Data formats such as JSON or CSV contain state, logs represent change, and language conveys meaning. BEAT combines these three layers into a single structure. It understands meaning without parsing (Semantic), preserves information in its original state (Raw), and maintains a fully organized structure (Format). Therefore, BEAT is the Semantic Raw Format (SRF) standard.

Simply put, BEAT doesn’t format the content of data (Key + Value). It formats the relationships within data (Space + Time + Action). And this value does not stay within the web. In the AI era, BEAT begins a new category where the data format itself becomes grammar.

• Finance domain example (*action:price:quantity)
  
  trader_1=!open~182*nvda!orderbook-NVDA~941*buy-NVDA:188:40
  trader_2=!open~1*nvda!orderbook-NVDA~1*buy-NVDA:market:5000

  // Adaptive execution and relay routing for HFT and MEV patterns

  ---

• Game domain example (~time^distance)
  
  player_1=!online~34^231~121^972*move~5/1/1/1/1/1/1*shoot-auto~251^1682*move~11*shoot-single:1-kill
  player_2=!online~1^3215*move!ban

  // 1 second travel 3215, clear speedhack spike, instant ban

  ---

• Healthcare domain example (*status:heartrate:bloodoxygen)
  
  wearable_1=!normal~60*good:HR-80:SpO2-98~60*good:HR-82:SpO2-97~60*good:HR-81:SpO2-98
  wearable_2=!normal~60*good:HR-82:SpO2-96~60*caution:HR-95:SpO2-92!priority-high~10*caution:HR-104:SpO2-88~10*danger:HR-110:SpO2-85!emergency

  // Monitoring interval tightened from 60s to 10s upon risk escalation

  ---

• IoT domain example (*status:value)
  
  sensor_1=!start~100/100/100/100/100/100/100/100/100*temp:23.5
  sensor_2=!start~100/100/100*temp:23.5~86*temp:24.1~37*temp:26.4*alert:overheat!emergency~10!recovery~613!restart~100/100/100

  // AI detected abnormal state and executed emergency recovery and restart

  ---

• Logistics domain example (*action:reason)
  
  flight_1=!JFK~2112*load~912*depart~486*climb~8640*cruise!MEM~2514*unload~1896*sort~3798*depart~522*climb~32472*cruise!CDG~3138*unload
  flight_2=!JFK~2046*load~864*depart~462*climb~8424*cruise!MEM~872*ramp-hold:ground-capacity~6514*unload

  // Abnormal flight operations captured via real-time monitoring and logging

Here’s a more intuitive way to see BEAT’s benefits in the logistics domain.

BEAT can stream the entire daily schedule of a single aircraft in about 1KB of data. There are roughly 30,000 commercial aircraft in operation worldwide. Archived for one year, all of that can fit on a 10GB USB drive.

On that drive, all key flight operations from the first takeoff to the final landing of each aircraft are preserved in a form that requires no semantic parsing. It also makes visible delay reasons and operational patterns that traditional systems often hide across separate logs.

For additional detail, BEAT can be extended with value parameters like !JFK:pilot-LIC12345 or *depart:fuel-42350L, maintaining readability while adding precision.

BEAT can also be processed natively on AI Accelerators (xPU). As a pre-tokenized and strictly structured sequence format, BEAT is inherently optimized for massive parallel processing and large-scale AI training. Below is an example Triton kernel that encodes BEAT tokens directly in xPU memory.

• xPU platform example (1-byte scan)
  
  s = token == ord('!') # Contextual Space (who)
  t = token == ord('~') # Time Flow (when)
  p = token == ord('^') # Position (where)
  a = token == ord('*') # Action (what)
  m = token == ord('/') # Method (how)
  v = token == ord(':') # Value (why)

  # Binary-level BEAT scanning on xPU

xPU can scan BEAT sequences directly without any additional preprocessing. The rest is just address arithmetic to load and store tokens. In short, it delivers binary-level performance while preserving the human readability of a text sequence.

 

 

Q4. Is there a dashboard for analysis?

A. Optional. This system is designed to be analyzed through natural language conversations with AI, so your preferred AI assistant serves as the primary interface for interpreting BEAT. As AI evolves, systems built on BEAT evolve with it.

For those preferring traditional dashboard analysis over AI, it's also possible to implement this directly by storing NDJSON in Cloud Storage and connecting it to your existing analytics or BI tools. Since the BEAT format contains storytelling elements, user journeys could be visualized as 🔗 tree-structured flowcharts like Detroit: Become Human's. It might be interesting to explore someday if time permits.

 

 

Q5. Is a localStorage version available?

A. The localStorage version is kept in a private repository. It uses localStorage instead of cookies, and sessionStorage instead of window.name.

While it has advantages in response speed and stability compared to the cookie version, it has the disadvantages of slightly longer code length and limited browser support coverage. Also, unlike cookies, real-time analysis via resonance requires a semi-automatic trigger.

It is difficult to say which is better, but the currently released cookie version aligns better with the developer's values and philosophy. Therefore, the localStorage version will be maintained solely for license protection and development research purposes.

 

 

Q6. Can it be used without Edge?

A. Yes. While Full Score resonating with Edge requires no API endpoints, it is easy to connect external channels if needed. Even streaming features like Bot Security & Human Personalization can be implemented natively within the browser.

However, this increases the client-side code volume, and manually implementing or integrating external sources would be required for features already well-equipped in Edge, such as WAF, AI, and Log Streaming.

 

 

Q7. Is Full Score really 3KB?

A. Yes, based on minified and gzipped size. The three versions come in at 2.69KB, 3.13KB, and 3.30KB.

• Basic (2.69KB): https://cdn.jsdelivr.net/gh/aidgncom/fullscore@main/fullscore.basic.min.js
• Standard (3.13KB): https://cdn.jsdelivr.net/gh/aidgncom/fullscore@main/fullscore.standard.min.js
• Extended (3.30KB): https://cdn.jsdelivr.net/gh/aidgncom/fullscore@main/fullscore.extended.min.js

The Basic version is recommended for most sites. This version includes only BEAT (core) and RHYTHM (engine), without TEMPO (auxiliary module). It operates without issues on most sites.

If clicks or taps register incorrectly when testing the Basic version, this typically indicates problems with your site's event handling or coordinate setup. The Standard version includes TEMPO, which resolves these issues elegantly.

For Power Mode activation or scroll depth tracking, consider the Extended version with add-on features. Most sites won't need this. Use it only when your specific situation requires these features.

The script runs smoothly even when placed in your site’s footer. If you want to change the default settings, you can customize them as shown below.

Full Score provides detailed customization options and can operate independently of Edge through custom endpoints.

While real-time analytics and security layers based on event sequences can be implemented directly on the client side, deploying to Edge maximizes Full Score's capabilities with features like WAF blocking, personalized functionality, AI analysis, and log pushing to cloud storage.

Resonator is the official BEAT interpreter. The setup process in the YouTube video is simple to follow.

---

Contact

The core of this project is BEAT, and Full Score was created to demonstrate the concept and practical value of the Semantic Raw Format. The term "SRF" came from conversations with my AI assistant, who stayed with the project through its final stages.

Full Score is a personal project by Aidgn. I primarily work as a UX consultant, so my development work is naturally connected to user experience.

As the next project following Full Score, I am currently researching a new rendering approach called FFR (Full-Cache Fragment Rendering). If SRF aims to remove the data pipeline, FFR aims to remove the rendering pipeline.

If you would like to get in touch, feel free to reach out via email or DM on X. Thank you.

• 📧 Email: [email protected]
• 💬 X: https://x.com/aidgncom
• 🎬 YouTube: https://www.youtube.com/@aidgn
• 🎼 Full Score: https://github.com/aidgncom/fullscore
• 🎛️ Resonator: https://github.com/aidgncom/resonator