#urlshortener — Public Fediverse posts

Creating Your First Shortened URL with Shrno: A Practical Guide

Walk through how to create your first shortened URL with Shrno, from account setup to custom aliases, with clear steps and common fixes for engineers.

https://nidavellirs.com/blogs/creating-your-first-shortened-url-with-shrno-create-first-shortened-url

#shrno #urlshortener #engineering #devtools

Ab sofort gibt’s den t-w.us URL-Shortener auch als offizielle Browser-Erweiterung! 🚀

Egal ob Chrome, Brave oder Firefox: Kürze deine Links jetzt direkt mit nur einem Klick – blitzschnell, komplett ohne Tracking und 100 % kostenlos.

Hol dir das Add-on direkt im Store und sparre dir den Umweg über die Webseite! 🔗👇

https://t-w.us/

https://t-w.us/zy2c78

https://t-w.us/yxafbe

#UrlShortener #FirefoxAddons #ChromeExtension #WebTools #Datenschutz

Technisch korrekt heißt noch lange nicht gut bedienbar. Gerade bei Admin-Tools entscheidet die UI, ob ein Bulk-Prozess läuft oder im Chaos endet.

@svenruppert zeigt am #URLShortener, wie Validieren, Korrigieren und Erzeugen getrennt werden: https://javapro.io/de/urlshortener-simple-bulk-creation/

#Java #Vaadin

🔗 urlhum/UrlHum

The modern, privacy-aware URL Shortener built in PHP.

Shortens URLs with privacy-focused features like IP anonymization and analytics tracking in an admin panel

⭐ Stars: 689
📅 Last Update: Jul 13, 2026

https://github.com/urlhum/UrlHum

#selfhosted #homelab #selfhost #selfhosting #opensource #urlshortener #privacy

🔗 SinTan1729/chhoto-url

A simple, blazingly fast, selfhosted URL shortener with no unnecessary features; written in Rust.

Shortens URLs with configurable expiry, hit counting and custom slugs, built for minimal resource usage

⭐ Stars: 900
📅 Last Update: Jul 09, 2026

https://github.com/SinTan1729/chhoto-url

#selfhosted #homelab #selfhost #selfhosting #opensource #urlshortener

🔗 nelsontky/gh-pages-url-shortener

Minimal URL shortener that can be entirely hosted on GitHub pages.

Shortens URLs using GitHub issues as a database and GitHub Pages for hosting, requiring no server or backend

⭐ Stars: 1409
📅 Last Update: Jun 04, 2026

https://github.com/nelsontky/gh-pages-url-shortener

#selfhosted #homelab #selfhost #selfhosting #opensource #urlshortener #githubpages

🔗 Stop sharing ugly long URLs!

Use our FREE URL Shortener to turn messy links into clean, shareable ones in seconds ⚡

✅ No signup required
✅ Instant results
✅ Works on any link

👉 Try it now → toolkitspro.online

#URLShortener #FreeTools #SEOTools #DigitalMarketing #WebTools #Productivity #LinkShortener

Ein zentrales Problem bei Imports: Unsicherheit über Konflikte & ungültige Datensätze. @svenruppert macht diese Zwischenzustände in #Vaadin sichtbar, bevor ein Apply überhaupt möglich ist.

Wer Imports baut, sollte das sehen: https://javapro.io/de/url-shortener-import-und-vaadin/

#URLShortener #Java @vaadin

Der spannendste Teil am JSON-Export ist nicht #JSON. Es ist Vorhersagbarkeit. Sven Ruppert baut Exporte, die sich exakt aus dem UI erklären lassen — ohne versteckte Parameter. Lies rein: https://javapro.io/de/url-shortener-json-export-in-vaadin-flow/

@vaadin #EclispeStore #URL #vaadin #JAVAPRO #Java #URLShortener

RE: https://mastodon.online/@shaedrich/116584488378626411

#URLShortener mögen selbst noch so datenschutzfreundlich sein, aber wenn sie zufällige oder benutzerdefinierte Zeichenketten benutzen, können sie nicht verhindern, dass nichtsahnende Benutzer*innen, die Wert auf den Schutz ihrer Daten werden, auf datenschutzfeindliche Seiten gelockt werden. Gib es Services, die
– Warnen, wenn auf datenschutzfeindliche Seiten weitergeleitet werden soll?
– Die Domain der Seite in ihrem Kurzlink menschenlesbar codieren?

#FollowerPower #privacy #GerneRT

Technisch korrekt heißt noch lange nicht gut bedienbar. Gerade bei Admin-Tools entscheidet die UI, ob ein Bulk-Prozess läuft oder im Chaos endet.

@svenruppert zeigt am #URLShortener, wie Validieren, Korrigieren und Erzeugen getrennt werden: https://javapro.io/de/urlshortener-simple-bulk-creation/

#Java #Vaadin

L8: mai più #link lunghi e noiosi
#urlshortener #utility @internet

https://webappsmagazine.blogspot.com/2026/04/l8-mai-piu-link-lunghi-e-noiosi.html

Dub: molto più di un semplice abbreviatore di #link
#urlshortener @internet @opensource

https://webappsmagazine.blogspot.com/2026/03/dub-molto-piu-di-un-semplice.html

Schon mal Imports gebaut, die still und heimlich Daten überschreiben? @svenruppert macht im #URLShortener das Gegenteil: Import als sichtbarer UI-Zustand, nicht als Hintergrundprozess. Kontrolle statt Chaos.

Lese: https://javapro.io/de/url-shortener-import-und-vaadin/

#Java #EclipseStore #Vaadin @vaadin

🚀 In Arbeit: URL-Kürzer 2.0 für den QR-Code Creator

Komplett selbst entwickelt – ohne Tracking, ohne Datensammlung.
Links können jederzeit selbst gelöscht werden.
Gezählt wird nur, wie oft ein Link geöffnet wurde – keine IPs, keine Profile.

DSGVO-freundlich und datensparsam gedacht.

👉 https://qr-cc.de

Manche Funktionen setzen ein aktiviertes Logo-Modul I od. II voraus.

#QRCodeCreator #DSGVO #PrivacyFirst #NoTracking #URLShortener

Our Weekly Update #64 is live! 🎥✨

Watch now: https://youtu.be/X9TXNIIymsg
Don’t forget to subscribe & hit the bell 🔔!

Subscribe to our weekly newsletter!
👉 https://urlroulette.net/newsletter/subscribeform 🚀

#urlshortener #randomstuff #languages #emotions #zengarden

Ein zentrales Problem bei Imports: Unsicherheit über Konflikte & ungültige Datensätze. @svenruppert macht diese Zwischenzustände in #Vaadin sichtbar, bevor ein Apply überhaupt möglich ist.

Wer Imports baut, sollte das sehen: https://javapro.io/de/url-shortener-import-und-vaadin/

#URLShortener #Java @vaadin

Der spannendste Teil am JSON-Export ist nicht #JSON. Es ist Vorhersagbarkeit. Sven Ruppert baut Exporte, die sich exakt aus dem UI erklären lassen — ohne versteckte Parameter. Lies rein: https://javapro.io/de/url-shortener-json-export-in-vaadin-flow/

@vaadin #EclispeStore #URL #vaadin #JAVAPRO #Java #URLShortener

Schon mal Imports gebaut, die still und heimlich Daten überschreiben? @svenruppert macht im #URLShortener das Gegenteil: Import als sichtbarer UI-Zustand, nicht als Hintergrundprozess. Kontrolle statt Chaos.

Lese: https://javapro.io/de/url-shortener-import-und-vaadin/

#Java #EclipseStore #Vaadin @vaadin

JSON export in Vaadin Flow

Export functions are often seen as a purely technical side task: one button, one download, done. In a Vaadin-based application, however, it quickly becomes apparent that exporting is much more than writing data to a file. It is a direct extension of the UI state, an infrastructural contract between frontend and backend, and a decisive factor for maintainability and predictability.

1. Export from a UI point of view: more than a download button
2. Initial situation: functional export, but non-UI
3. Design Goal: Export as a Deterministic UI Workflow
4. Uniform responses as a prerequisite for clean UI logic
5. Filter logic as a common language between the grid and export
6. Download mechanics in Vaadin: Button ≠ Download
7. StreamResource: Export on demand instead of in advance
8. Paging boundaries as a protective mechanism
   1. Real JSON export from the running system
9. Effects on maintainability and comprehensibility
10. Conclusion

This article shows how a JSON-based export was deliberately designed as a UI-driven workflow in the URL shortener project. The focus is not on file formats or complex backend abstractions, but on the clean embedding of the export in a Vaadin Flow interface: filter coupling, download mechanics, paging boundaries and clear responsibilities between UI, client and server.

The current source code can be found on GitHub under https://github.com/svenruppert/url-shortener or https://3g3.eu/url

Export from a UI point of view: more than a download button

In classic web applications, export is often thought of as an isolated API endpoint. From the perspective of a Vaadin UI, this consideration falls short. For the user, export is not a technical process but a consequence of the current UI state: the filters applied, the sorting, and the paging limits.

An export that ignores this coupling immediately leads to cognitive breaks. The display in the grid shows a certain amount of data, but the export provides something else – be it more, less or simply different data. This is exactly where it is determined whether an application is perceived as consistent.

The claim in the project was therefore clear: The export is not a special function, but a mirror of the UI state.

This decision shapes all further design steps – from the filter generation to the download mechanics to the structure of the export data itself.

Initial situation: functional export, but non-UI

Before the revision, an export was already technically possible. Data could be read on the server and returned to the client as JSON, ensuring the basic functionality was fulfilled. However, from a user interface perspective, this implementation introduced several structural issues that only became apparent upon closer inspection.

The response structures were inconsistent and required the client to interpret them in context. The meaning and interaction of HTTP status codes and response bodies were not explicitly defined; they were derived from implicit assumptions in the client code. At the same time, there was no clear connection between the export and the currently visible filters in the interface. From the UI’s perspective, it was only possible to trace the data that was actually exported indirectly. In addition, there was special logic for empty results or error cases that could not be derived consistently from the response itself but were distributed across several places in the client.

From Vaadin’s perspective, the export was not an integrated UI workflow but rather an isolated technical endpoint. The UI had to provide knowledge of special cases, status codes, and response formats that were not explicitly covered by a contractually defined framework. This state of affairs was also reflected in the test landscape: tests were often based on concrete string representations or complete JSON output rather than on clearly defined functional structures. Changes to filters, sorting or response formats therefore had to be followed up in several places and carried an increased risk of unintended side effects.

In short, the export worked technically but did not meet the requirements for a UI-enabled, traceable, and maintainable component in a Vaadin application.

Design Goal: Export as a Deterministic UI Workflow

The central goal of the redesign was not “more features”, but predictability. For the Vaadin UI, this means:

The export uses the same filters as the grid and thus reflects the current UI state. Paging limits are deliberately set and comprehensible for developers and users alike, so that the scope and character of the export remain clearly recognisable. Success, empty results and error cases are clearly distinguishable and can be handled in the UI without special logic. At the same time, the download behaves browser-compliantly and UI-stably without affecting the current UI state.

From the UI’s perspective, an export must not have its own state. He must not “think” anything, expand anything, or change anything implicitly. It is a snapshot of what the user sees – nothing more, nothing less.

Uniform responses as a prerequisite for clean UI logic

In a Vaadin application, API responses have an immediate effect on the UI code, as each response is typically translated directly into UI states, component logic, and user feedback. In contrast to purely client-side frontends, the UI logic is tightly coupled to server-side processing: Each response directly updates component state, enables or disables controls, and renders feedback to the user.

In this context, inconsistent response formats inevitably lead to complex if-else cascades in the UI code. Special treatments for seemingly trivial cases, such as “empty” exports or different error states, must be explicitly requested. The UI code starts by interpreting technical details of the API – such as certain HTTP status codes or the presence of individual JSON fields – instead of relying on clearly defined business signals. This not only increases the code complexity but also complicates the interface behaviour during extensions, making it harder to understand and more error-prone.

In the URL shortener project, this problem was solved by introducing an explicit and stable response structure. Regardless of whether an export record is empty or contains an error, the response always follows the same structure. HTTP status codes are still used to signal the rough outcome of a request, but they do not serve as the sole signifier. The actual technical information – such as the context, scope, and content of the export – is transmitted in full and consistently in JSON format.

A simplified, real export from the system illustrates this approach:

 {    "formatVersion": "1",    "mode": "filtered",    "exportedAt": "2026-02-05T11:28:54.582886239Z",    "total": 9,    "items": [ /* subject records */ ]  } 

This creates a clear and stable contract for the Vaadin UI. The UI code can rely on the fact that metadata such as mode, exportedAt, or total is always present and interpreted consistently. The interface no longer has to guess whether an export was successful or whether there are special cases. Instead, the process can be designed in a linear, deterministic way: metadata is evaluated, the scope is checked, and the user data is processed or reported back to the user.

This structure has far-reaching consequences for UI logic. Loading indicators, confirmation dialogs or error messages can be derived directly from the structured response, without additional special logic or context-dependent checks. This keeps the interface clear, predictable, and closely linked to the technical significance of the answer, rather than tied to technical special cases or implicit assumptions.

Filter logic as a common language between the grid and export

A crucial Vaadin-specific point is the reuse of the filter logic. There is no separate export filter in the project. Instead, the export is generated exclusively from the current UI state.

The SearchBar acts as the only source of truth:

 public UrlMappingListRequest buildFilter(int page, int size) {    UrlMappingListRequest req = new UrlMappingListRequest();    req.setPage(page);    req.setSize(size);    req.setActiveState(activeState);    req.setCodePart(codeField.getValue());    req.setUrlPart(urlField.getValue());    req.setFrom(from);    req.setTo(to);    req.setSort(sort);    req.setDir(dir);    return req;  } 

This Request object is used for both grid display and export. This guarantees:

Display and export thus produce identical results, since both are based on the same filter definitions. Changes to filters or collations automatically and consistently affect display and export without requiring additional code. At the same time, there are no hidden or implicit export parameters, so the export behaviour can be fully explained by the UI state.

From a maintenance perspective, this is a significant advantage: if you understand the UI, you understand the export.

Download mechanics in Vaadin: Button ≠ Download

A common mistake in Vaadin applications is trying to start a file download directly from a button click. Technically, this is problematic: a button click primarily triggers server-side logic, whereas a download is a resource from the browser’s perspective.

In Vaadin, a button click is primarily a server-side UI event. The browser does not send a “classic” download request; instead, Vaadin processes the click via its UI/RPC communication (server round-trip, event listener, component update). From the browser’s perspective, this is not a normal navigation or resource retrieval. And that’s exactly why “button clicks → browser downloads file” is not reliable, because the browser typically only starts a download cleanly when it retrieves a resource (link/navigation) or submits a form – i.e. something that is perceived in the browser as a “real request for a file”.

The anchor (<a>) element solves this problem because it is a standard download target for the browser: it has an href attribute that points to a resource, and the download attribute signals to the browser: “This is a file”. In Vaadin, you bind this href to a StreamResource. This creates a separate HTTP request when clicking the anchor, which is not part of the Vaadin UI event flow but rather an independent resource retrieval. Only at this moment is the StreamResource “pulled”, and the export content is generated on demand.

In practice, this has three major advantages:

1. Browser compliance and reliability: The download is started via a mechanism that the browser natively supports. This reduces edge cases in which a download triggered by a UI event is blocked or behaves inconsistently (e.g., pop-up/download policies, timing, UI updates).
2. Decoupling from the UI lifecycle: The download occurs in a separate request. Even if Vaadin processes UI requests in parallel, if the user clicks on or rerenders the interface, the download can continue to run stably. This is especially important if export generation takes longer or is streamed.
3. Clean accountability: The button is purely UI/UX (icon, tooltip, permissions, enable/disable, visual feedback). The anchor is purely “transport” (browser download). The StreamResource is purely a “data supplier” (the export is generated only when needed). This separation makes the code more maintainable and reduces the side effects.

 Button btnExport = new Button(VaadinIcon.DOWNLOAD.create());  btnExport.setTooltipText("Export current result set as ZIP");  btnExport.addClickListener(e ->      exportAnchor.getElement().callJsFunction("click")  ); 

The actual download behaviour is in the anchor connected to a StreamResource:

 StreamResource exportResource =      new StreamResource("export.zip", () -> {        UrlMappingListRequest filter =            searchBar.buildFilter(1, chunkSize);        return urlShortenerClient.exportAllAsZipDownload(filter);      });  exportAnchor.setHref(exportResource);  exportAnchor.getElement().setAttribute("download", true); 

This pattern clearly separates the responsibilities: the UI interaction is limited to the button, which serves exclusively as a trigger for export. The browser download is triggered via the anchor element and is therefore treated as a regular resource request. Finally, the data is made available via the StreamResource, which only generates the export content when it is actually downloaded.

The export is only generated when the browser actually retrieves the resource – not when the user clicks on it.

StreamResource: Export on demand instead of in advance

The use of StreamResource is not a detail, but a deliberate architectural decision. The export is generated on demand while the browser reads the stream.

This has several advantages. On the UI side, the memory footprint remains low because the export does not need to be fully pre-generated and buffered. At the same time, the UI thread is not blocked because the data transfer occurs outside the regular UI lifecycle. The download can continue regardless of the current UI state, even if the user navigates or performs further actions during this time. If errors occur during stream generation, they can be propagated cleanly via a separate HTTP request without causing the UI state to become inconsistent.

The export is thus technically decoupled from the UI lifecycle, although it is logically triggered by the UI.

Paging boundaries as a protective mechanism

Another explicitly UI-related aspect of the export implementation is the deliberate limit on export quantity. The export uses the same chunkSize as the grid in the interface and is additionally limited by a fixed upper limit. This decision ensures that the export always remains within a clearly defined framework and can be derived directly from the current UI state.

From an architectural perspective, this limitation prevents the export from processing large amounts of data in an uncontrolled manner when a user triggers an export. Especially in Vaadin applications, where UI interactions are typically synchronous with server-side logic, this protective measure is crucial. It reduces the risk of heavy memory loads, long runtimes, or blocking operations that could negatively impact other users or the entire server.

At the same time, the paging boundary conveys a clear technical semantics to the outside world. The export is deliberately defined as an image of the currently visible result set. It mirrors exactly what the user sees in the grid, including filtering, sorting, and paging configurations. This does not imply a claim to completeness, as is typically associated with a backup.

This clarity is particularly relevant for user expectations. The export does not provide a complete system print or a historically complete data set, but a specifically selected excerpt. The limitation makes this character explicit and prevents misinterpretations, such as assuming that an export can fully restore the system.

From a maintenance and operations perspective, the paging boundary also serves as a natural safety line. It forces us to consciously design export scenarios and, if necessary, to provide separate mechanisms for backups or mass data withdrawals. As a result, the export remains a controllable UI tool and does not insidiously become an infrastructural backdoor for unlimited data queries.

In summary, limiting export volume is not a technical constraint but a deliberate design decision. It combines UI state, user expectations and system stability into a consistent overall picture and underlines once again that the export in the URL shortener is understood as a UI-driven result set – and expressly not as a substitute for a backup.

Real JSON export from the running system

The architectural decisions described above are particularly well understood from a real export of the running system. The following JSON export was generated directly from the Vaadin interface and represents a specific UI state at a defined point in time.

Even at the top level, the export contains all the necessary contextual information to enable independent classification. The formatVersion field explicitly defines the export format version, providing a stable foundation for future extensions. Changes to the internal data model do not automatically propagate to the export contract, provided the version limit is respected.

The field mode is deliberately chosen to speak. The filtered value makes it unmistakably clear that this is not a complete data deduction, but a result set restricted by UI filters. This information is crucial because it prevents the export from being mistakenly interpreted as a backup. The export does not capture the entire system state; it only includes the section the user has seen in the grid.

With exportedAt, the exact time of snapshot creation is recorded. The export thus clearly refers to a defined system state. Later changes to individual data records are deliberately not included and can be clearly delineated on the basis of this time stamp. This context is supplemented by the total field, which indicates the number of exported data records and enables a quick plausibility check without analysing the actual user data.

The actual technical data is located exclusively in the items array. Each entry describes a single URL-mapping dataset, including subject-relevant properties such as shortCode, originalUrl, and active, as well as temporal attributes createdAt and, optionally, expiresAt. It is notable that these objects contain no UI or export-specific metadata. They are deliberately reduced to the technical core and could also come from other contexts in the same form.

It is precisely this clear separation between top-level metadata and functional user data in the items array that makes the export an explainable artefact in itself. Even without knowledge of the internal code or the Vaadin interface, it is possible to determine when the export was created, under what conditions, its scope, and where the actual technical data begins.

The real export thus confirms the design goals described above. It is reproducible, rich in context and clearly recognisable as a UI-driven result set. Instead of merely transporting data, it also conveys its meaning and context of creation – a property that is crucial for maintainability, analysis and long-term further processing.

Effects on maintainability and comprehensibility

The tight coupling between the export and the UI state ensures behaviour that is predictable for developers and users alike. The export follows the same rules as the grid display and contains no hidden special paths or implicit deviations. As a result, the export automatically evolves with the UI: any adjustment to filters, sorting, or paging mechanisms has a consistent effect on both paths without requiring additional synchronisation code.

From a developer’s perspective, this architecture significantly reduces cognitive load. There is no separate mental model space for exporting, as its behaviour can be completely derived from the known UI state. If you understand the grid and its filter logic, you automatically understand the export. This not only simplifies onboarding new developers but also reduces the risk of unintentional inconsistencies during refactorings or functional enhancements.

Testability also benefits directly from this clarity. Since the export has no state and relies on stable request and response structures, it can be tested in isolation. Tests can be run with specific filter combinations and validate the resulting exports without simulating the entire UI or complex interaction sequences. At the same time, UI tests remain lean because they can focus on correctly generating the filter state.

In the long term, this structure improves the maintainability of the overall system. Changes to the UI do not introduce hidden side effects in the export, and conversely, further development of the export does not require parallel adjustments elsewhere. The risk of divergent logic paths between display and export is not only reduced but systematically eliminated.

In summary, the close integration of UI state and export logic ensures that export is not a special case in the system. It becomes a transparent, explainable, long-term, and maintainable component of the application that fits seamlessly into the existing Vaadin architecture.

Conclusion

The export in the URL shortener is not an isolated API endpoint, but an integral part of the Vaadin UI architecture. It follows the same rules as the grid, uses the same filters and respects the same boundaries.

Vaadin Flow applications in particular show that a cleanly integrated export is less a question of the file format – and much more a question of clear responsibilities, explicit contracts and a consistently conceived UI workflow.

🔗 UrlRoulette URL of the Day #426! 🌟

CreepyLink
The URL shortener that makes your links look as suspicious as possible.

This is our URL of the day 👉 https://urlroulette.net/ui/4pk5jG49RLz3 🚀

#urlshortener

jo4.io: 1 URL ngắn SaaS với phân tích chính xác, trang bio, domain tuỳ chỉnh. Trong 48 ngày có 100 người dùng (5% trả phí) nhờ 500$ quảng cáo và SEO kỹ thuật. Cạnh tranh với Bitly/TinyURL. #SaaS #Startup #Marketing #KinhDoanh #URLShortener #Khoasat #HocTap #QuảngCao #DigitalMarketing

jo4.io – URL shortener SaaS với 100+ người dùng, 5% chuyển đổi trong 48 ngày, ngân sách 500$. Tính năng: phân tích, domain tuỳ chỉnh, API, trang bio. Cạnh tranh với Bitly hiệu quả nhờ SEO & quảng cáo. #Tech #Entr

What is Snipper Link?

Not just another URL shortener.

One dashboard to manage all your links:
— Real-time click analytics
— A/B testing with traffic splitting
— Geo-routing to 195 countries
— Device-based redirects
— Your own branded subdomain

Free plan includes everything above. No catch.

Pro and Business tiers add custom domains, API access, and team features when you need them.

#SnipperLink #URLShortener #AdTech #LinkManagement #DigitalMarketing

Dev đang phát triển SaaS glnk – công cụ rút gọn URL đa năng. Cho phép nhúng pixel Facebook, Google, TikTok, theo dõi lượt click, quốc gia, thiết bị và thống kê thời gian thực. Hỗ trợ rút gọn hàng loạt, trực quan hoá dữ liệu, so sánh A/B cho hơn 50 link đồng thời. #SaaS #URLShortener #Marketing #CôngNghệ #KhởiNghiệp #DataAnalytics

https://www.reddit.com/r/SaaS/comments/1qkxd4y/a_glimpse_into_what_i_am_building/

Xây tool rút gọn link tưởng vui, hoá ra dành 90% thời gian để đấu spammer! Sau hàng trăm commit, tôi học được: kiểm duyệt phải làm NGAY từ ngày đầu. Monitor traffic, kiểm tra kỹ nội dung, hạn chế free tier, shadowban, blacklist domain độc hại, giới hạn tần suất, xác minh email & log fingerprint thay IP. Spammer không ngủ, hoá đơn tiền server cũng không! #SaaS #Spam #URLshortener #LessionLearned #AntiSpam #Phishing #CryptoScam #KhởiNghiệp #AnNinhMạng #XửLýSpam

https://www.reddit.com/r/SaaS/comme

Shlink: il self-hosted #URLshortener che ti ridà il controllo dei tuoi #link
#OpenSource @diggita @opensource

https://bit.ly/3NpwYLK

The URL shortener that makes your links look as suspicious as possible

https://creepylink.com/

#HackerNews #URLShortener #SuspiciousLinks #CreepFactor #InternetHumor #HackerNews

Moin @Zoll,

danke für eure tolle Arbeit! 👍

Kurze 🤓 Anmerkung:
Alle "Links" auf Mastodon benötigen nur "23 Zeichen" – egal welcher Länge.✅

👉 Ihr könntet daher auf #LinkShortener / #URLShortener (#KurzLinks) verzichten.
Diese verbergen leider wohin der "Link" wirklich führt und sind mit Blick auf den Datenschutz eher bedenklich!

👉 Alle "URLs" bzw. "Links" – beliebiger Länge – verbrauchen immer nur "23 Zeichen"!

👉 Bitte nutzt statt Kurzlinks wie 🚫 sohub.io/40an... 🚫 doch lieber die originalen und nachvollziehbaren "Links":

https://www.presseportal.de/blaulicht/pm/121264/6196157

Vielen Dank 👍 😃

Moin @Zoll,

danke für eure tolle Arbeit! 👍

Kurze 🤓 Anmerkung:
Alle "Links" auf Mastodon benötigen nur "23 Zeichen" – egal welcher Länge.✅

👉 Ihr könntet daher auf #LinkShortener / #URLShortener (#KurzLinks) verzichten.
Diese verbergen leider wohin der "Link" wirklich führt und sind mit Blick auf den Datenschutz eher bedenklich!

👉 Alle "URLs" bzw. "Links" – beliebiger Länge – verbrauchen immer nur "23 Zeichen"!

👉 Bitte nutzt statt Kurzlinks wie 🚫 sohub.io/hevj... 🚫 doch lieber die originalen und nachvollziehbaren "Links":

https://www.presseportal.de/blaulicht/pm/121258/6195209

Vielen Dank 👍 😃

Well, another thing checked off ✅, https://mtribe.link is live and working 🚀. My own privacy-focused URL shortener service is up and running - no tracking, no analytics, just redirects! 🎉 #URLShortener #SelfHosting #Privacy

🎄Tür verpasst? Jetzt #URLShortener-Adventskalender lesen: UI-Architektur statt Monolithen.

🔹 Tag 21: UI entkernen: BulkActions & SearchBar
https://javapro.io/de/adventskalender-2025-komponenten-extrahieren-teil-1/

🔹 Tag 22: Weniger View-Logik, klare Event-Flows
https://javapro.io/de/adventskalender-2025-komponenten-extrahieren-teil-2/

#Java #Vaadin @eclipsestore @svenruppert

🎄Tag 19: Wie verwaltet man Shortlinks kontrolliert statt destruktiv? Ein Aktiv-/Inaktiv-Modell erlaubt Pausieren von Links, Stoppen von Kampagnen & klaren Status über UI, API und HTTP.

#URLShortener-Adventskalender: https://javapro.io/de/adventskalender-2025-aktiv-inaktiv-modell-teil-1/

#Vaadin #EclipseStore @svenruppert

🎄Tag 18: Wie schützt man eine Admin-Oberfläche richtig? Nicht nur mit einem Login, sondern mit Route-Schutz, Sessions & sauberem Logout.

Einfach umgesetzt, ganz ohne Frameworks. Jetzt im #URLShortener-Adventskalender: https://javapro.io/de/adventskalender-2025-minimaler-login-prozess-teil-2/

#Java #Vaadin @microstream @Vaadin @svenruppert

🎄Tag 17 im #URLShortener-Adventskalender: Warum selbst kleine Admin-UIs Schutz brauchen & wie ein minimaler Login ohne Frameworks genau das leistet.

Ein Passwort, eine Config-Datei, klarer Zugriffsschutz: https://javapro.io/de/adventskalender-2025-minimaler-login-prozess-teil-1/
by Sven Ruppert

#OpenSource #Vaadin #EclipseStore

🎄 Tag 16 im #URLShortener-Adventskalender: Massenoperationen im Grid – Teil 2. Expiry-Daten gesammelt entfernen, klare Dialoge, sichere API-Semantik & produktive Tastatur-Shortcuts.

Profi-Workflows statt Einzelklicks - lese:
https://javapro.io/de/adventskalender-2025-massenoperationen-im-grid-teil-2/

#Java #Vaadin @svenruppert

🎄 Tag 15 im #URLShortener-Adventskalender: Massenoperationen im Grid. Mehrfachauswahl & kontextsensitive Bulk-Actions machen aus der Übersicht ein echtes Verwaltungstool.

Mehrere Links löschen oder Ablaufdaten setzen: https://javapro.io/de/adventskalender-2025-massenoperationen-im-grid-teil-1/

#Java #Vaadin @vaadin @svenruppert

🎄Habt ihr im Adventstrubel die letzten Türchen des #URLShortener-Adventskalenders verpasst? Jetzt nachholen:

🔹Tag 13 – Globale Suche & Advanced Filters https://javapro.io/de/adventskalender-2025-komplexe-suche/
🔹Tag 14 – RefreshGuard gegen UI-Flackern https://javapro.io/de/adventskalender-2025-von-ui-interaktionen-zu-einer-deterministischen-refresh-architektur/

#Java #Vaadin @Vaadin @svenruppert

🎄Tag 12: bringt die Basis, die Multi-Aliasse brauchen: robuste Redirects, klare GET-Validierung, konsistente Statuscodes. So bleibt der #URLShortener zuverlässig.

Technischen Ansatz & Learnings hier: https://javapro.io/de/adventskalender-2025-einfuehrung-multipler-aliasse-teil-2/

#Java #Vaadin #EclipseStore @svenruppert @vaadin

🎄Tag 11! Mehrere Aliasse pro Ziel-URL – endlich flexibel arbeiten. Perfekt für Kampagnen, Tracking & strukturierte Workflows.
Wie UI & Validierung das möglich machen → https://javapro.io/de/adventskalender-2025-einfuehrung-multipler-aliasse-teil-1/

#URLShortener #Java #Vaadin #EclipseStore #OpenSource #JAVAPRO @svenruppert

Sendet mir noch einmal nen PDF als Cloud-Link per adobe..... Der größte Blödsinn ever. 15kb PDF wird in die Cloud Anzeige geschoben und die Webseite ballert mehrere MB durch. Vom tracking mal abgesehen...

Ach ja, ich kann das sowieso nicht öffnen. Ich blocke alle adobe links (im WAN und LAN). Gleiches gilt für .google-sharelinks. könnte ich jedesmal explodieren, wenn ich sowas kriege. Kann und will ich nicht öffnen.

Niemand braucht das. Niemand will das.
#enshittification vom feinsten.

#adobe #google #urlshortener #cloud

Một công cụ rút gọn URL mới (beta) do người dùng tạo, hỗ trợ tạo liên kết ngắn & mã QR. Ưu tiên bảo mật, giao diện thân thiện, và giá cả hợp lý. Tính năng tương lai: miền tùy chỉnh, chia sẻ mạng xã hội, phân tích dữ liệu. Feedback & hỗ trợ từ người dùng sẽ được đánh giá cao. #URLShortener #CôngCụ #SaaS #BetaTesting #PhátTriểnMới

https://www.reddit.com/r/SaaS/comments/1ph7vmh/test_my_new_url_shortener_beta/

Một nhà phát triển đã xây dựng công cụ rút gọn URL mới, đạt độ trễ dưới 50ms toàn cầu nhờ Cloudflare Workers. Dịch vụ này có tính năng thông minh như chuyển hướng theo thiết bị (mobile/desktop) và định tuyến theo vị trí địa lý. Người tạo mời mọi người dùng thử và đóng góp ý kiến!
#URLShortener #CloudflareWorkers #SideProject #TechNews #CôngNghệ #DựÁnMới #RútGọnURL

https://www.reddit.com/r/SideProject/comments/1pcai5a/i_built_a_url_shortener/

🎄Heute öffnet sich Türchen 1 unseres #Java #URLShortener Adventskalenders. 24 Tage voller Features, Deep Dives & Architektur-Einblicke.

Warum ein eigener URL-Shortener?
Jetzt lesen: https://javapro.io/de/url%e2%80%91shortener-adventskalender-2025/
Autor: SvenRuppert

#OpenSource #Vaadin #Jetty #EclipseStore

Bitly quá đắt? Một dịch vụ rút gọn link mới tên urlcrop.org vừa ra mắt, tự nhận là lựa chọn thay thế tiết kiệm hơn. Với giá 5$/tháng so với 29.99$/tháng của Bitly, dịch vụ này cung cấp theo dõi link và mã QR với chi phí thấp hơn đáng kể.

#URLShortener #BitlyAlternative #TechNews #RútGọnLink #TiếtKiệm

https://www.reddit.com/r/SaaS/comments/1p8pv20/bitly_is_too_expensive_for_what_it_is/

Si vous êtes curieux de voir comment ça fonctionne sous le capot, ou si vous voulez contribuer, tout est sur GitHub : 🛠️ https://github.com/thedevs-network/kutt

Finies les URL à rallonge qui font peur ! Testez Kutt dès maintenant : 👉 https://k.blablalinux.be

#Kutt #URLShortener #OpenSource #GitHub #Productivité #Astuce

One Open-source Project Daily

The de facto standard self hosted URL shortener in PHP

https://github.com/YOURLS/YOURLS

#1ospd #opensource #bitly #hacktoberfest #php #shorturl #shortenurls #shortener #urlshortener #urlshortner #yourls

@benelux @geocaching

I completely forgot about https://opencaching.eu. Now I read there about https://coord.eu - an even shorte and more competent #URLshortener for #GeoCaching.
Thank you.

Introducing Chhoto URL Shortener: a lightweight, fast, and easy-to-set-up URL shortener for your web needs! Learn how to create shortened URLs like https://short.url/rYubNk with this Rust-based app https://youtu.be/ZUOmlHRaBow #ChhotoURL #URLShortener #Rust

💡 Smart Link Management + Earnings
Shorten URLs, monitor clicks, and earn money per click. Experience the power of professional link shortening.
🔗 https://url.seo-websiterank.com/

#ShortLinks #URLShortener #EarnMoney #MonetizeLinks #DigitalMarketing #SEO #OnlineIncome

💻 Optimize Your Links & Make Money
Track clicks, create custom short links, and generate revenue. Fast, secure, and user-friendly.
🔗 https://url.seo-websiterank.com/

#URLShortener #ShortLinks #EarnMoneyOnline #DigitalMarketing #LinkTracking #MonetizeLinks #SEO

🚀 Professional URL Shortener
Shorten, track, and monetize links easily. Perfect for online campaigns and social media marketing.
🔗 https://url.seo-websiterank.com/

#ShortLinks #URLShortener #EarnOnline #SEO #LinkTracking #DigitalMarketing #MonetizeLinks

📈 Link Shortening That Pays
Create short URLs, track clicks, and earn money from every link. Ideal for marketers, bloggers, and influencers.
🔗 https://url.seo-websiterank.com/

#URLShortener #ShortLinks #EarnMoneyOnline #LinkTracking #DigitalMarketing #MonetizeLinks #SEO