Forem: karolk

How I Started Contributing to Open Mercato (My Practical Approach)

karolk — Tue, 03 Mar 2026 14:33:42 +0000

How I Started Contributing to Open Mercato

Open source can feel intimidating when you're starting out.

You see large repositories, experienced contributors, long issue discussions, and public pull requests where anyone can review your code. For a while I kept thinking I should “learn more first” before trying to contribute.

Eventually I decided to just try.

I chose Open Mercato and approached it in a simple way — explore the project, understand how it works, and start with something small.

This is roughly how that process looked.

Why I Chose Open Mercato

I didn’t pick a repository randomly.

While browsing GitHub projects, Open Mercato stood out for a few reasons:

The repository was active — there were recent commits and pull requests.
Maintainers were responding to issues.
The documentation was detailed enough to understand what the project does.

That last point helped a lot. When documentation is decent, it removes a lot of the friction that usually stops people from getting started.

Spending Time Reading the Repository

Before writing any code, I spent some time just exploring the project.

I read through the README.md and the CONTRIBUTING.md, and then started looking around the repository structure. I opened a few different folders and files just to see how things were organized.

I also checked:

open issues
recently merged pull requests

Looking at merged PRs was particularly useful. It gave me a better idea of what maintainers expect from contributors and how changes are usually structured.

Instead of trying to guess how things worked, I tried to observe how the project was already evolving.

Looking for a Small First Contribution

At first I thought about trying something more ambitious, but I quickly realized that probably wasn’t the best way to start.

So I deliberately looked for something small.

Things like:

minor bugs
small improvements
documentation updates
small refactoring opportunities

The goal wasn't to make a big change. I mainly wanted to understand the workflow and see how contributions are reviewed.

Starting small made the whole process feel much less intimidating.

Opening the Pull Request

Once I found something I could improve, I followed the usual GitHub process:

fork the repository
create a separate branch
implement a small change
write a clear commit message
open a pull request

When creating the PR, I tried to explain clearly:

what the change does
why it improves the project
whether it might affect anything else

Maintainers review a lot of contributions, so clear explanations make that process easier.

Feedback From Maintainers

After opening the pull request, I received some feedback.

It wasn’t really criticism — it was mostly suggestions to make the change align better with the existing code style and structure.

This part was actually very helpful. Seeing how maintainers think about code quality and consistency gave me a better understanding of how the project is maintained.

I updated the PR based on the comments and continued the discussion there.

What I Learned From the Process

One thing that stood out to me is that contributing to open source involves a lot more than just writing code.

You spend a lot of time:

reading other people's code
understanding design decisions
communicating clearly in pull requests and discussions

Another thing I realized is that you don't need to be an expert to start contributing. Even small improvements can be valuable, especially in active projects.

If You're Thinking About Contributing

If you're considering contributing to open source but aren't sure where to begin, a few things helped me:

choose a project that actually interests you
spend time reading the repository before coding
start with small, manageable changes
don't worry too much about making everything perfect

Once you go through the contribution process once, it becomes much easier the next time.

Final Thoughts

My first contribution to Open Mercato was relatively small, but the experience was valuable.

It helped me understand how open source collaboration works in practice — from exploring a repository to discussing changes in a pull request.

If you're thinking about contributing to a project, it's worth trying. The first step is usually the hardest part.

From Static Timeline to Fully Interactive Scheduler: Drag & Drop in My React Native Library

karolk — Sun, 01 Mar 2026 20:45:01 +0000

I Built a React Native Scheduling Timeline Library — and Now It Supports Drag & Drop, Resize & Smart Overlaps

A while ago, I shared that I built a time-based scheduling timeline library for React Native. It was designed to handle complex layouts like planners, booking systems, and EPG-style interfaces.

Today, I’m excited to share a major update:

The library now supports Drag & Drop, Resize interactions, and intelligent overlap stacking.

This transforms it from a static timeline component into a fully interactive, production-ready scheduling tool.

Why I Built It

If you’ve ever tried building a scheduling UI in React Native, you probably know how tricky it gets.

Some of the challenges include:

Precisely positioning events based on time
Handling horizontal and vertical scrolling simultaneously
Virtualizing large datasets for performance
Synchronizing headers and content
Supporting TV platforms and remote navigation
Keeping performance smooth on tablets and lower-end devices

There wasn’t a flexible, production-ready solution that covered these needs — so I decided to build one.

What the Library Does

The timeline component allows you to:

Render events across a horizontal time axis
Group events by rows (resources, users, rooms, etc.)
Scroll horizontally through time
Scroll vertically across resources
Handle large datasets efficiently
Customize rendering and styling
Automatically detect and stack overlapping events

It works across iOS, Android, and TV platforms, and is built purely in React Native.

Drag, Drop & Resize

The timeline now supports full gesture-based editing.

You can:

🟢 Drag events horizontally to change their time
🟢 Drag events vertically to move them between rows
🟢 Resize from the left edge to update the start time
🟢 Resize from the right edge to update the end time

Resize handlers are fully implemented and designed to feel natural and responsive, even during fast interactions.

Everything is calculated in real time — no hacks, no WebViews.

Smart Overlap Detection & Stacking

Scheduling systems must handle overlapping events gracefully.

The library now includes:

Automatic overlap detection
Intelligent stacking logic
Dynamic recalculation during drag & resize
Clean visual separation of colliding events

When events overlap in time, they are stacked vertically within the same row — similar to professional calendar systems.

This ensures:

Clear visual hierarchy
No hidden events
Accurate collision handling
Smooth recalculation while dragging or resizing

Handling this dynamically while maintaining performance was one of the most challenging parts of the implementation.

Under the Hood

Adding DnD, resize handlers, and overlap detection was not trivial.

Some of the technical challenges solved:

Handling simultaneous vertical + horizontal gestures
Real-time time recalculation during drag
Snap-to-time logic
Dynamic width adjustments while resizing
Collision detection during movement
Overlap stacking recalculation
Preventing layout thrashing
Maintaining high FPS during re-renders
Avoiding unnecessary computations

Performance was a top priority from day one.

Real-World Use Cases

With drag-and-drop, resize, and overlap stacking support, the library is ready for serious scheduling scenarios:

📅 Booking systems
🏥 Medical scheduling
👥 Shift planning
📺 TV program guides (EPG)
🏢 Resource management tools
🛠 Production planning systems
🏫 Classroom or training schedules

It’s no longer just a timeline — it’s a fully interactive scheduler engine.

Current Status

The library is currently in beta.

I’m actively improving:

API ergonomics
Performance optimizations
Edge-case handling
Documentation
TypeScript support
Advanced stacking configuration options

Feedback from real-world usage is extremely valuable at this stage.

What’s Next?

Planned improvements include:

More advanced collision rules
Enhanced performance profiling tools
Additional customization hooks

Final Thoughts

Building a robust scheduling timeline in React Native is much harder than it looks.

Adding smooth drag-and-drop, resize handlers, and real-time overlap stacking — while keeping performance high across devices — was a serious engineering challenge.

But now, the component feels complete.

If you’re building anything time-based in React Native, I’d love to hear your thoughts or feedback.

The journey continues

I Built a React Native Scheduling Timeline Library — Here’s Why

karolk — Sat, 07 Feb 2026 13:11:28 +0000

I Built a React Native Scheduling Timeline Library — Here’s Why

Scheduling UIs look simple… until you try to build one.

After working on multiple products that required time-based layouts — planners, calendars, EPG-style TV guides, and complex schedulers — I realized how quickly things become complicated:

precise time positioning
virtualization and performance
scrolling synchronization
focus handling on TV devices
responsive layouts for mobile and tablet
drag & drop interactions
real-world edge cases everywhere

I described many of these challenges in detail in this article:

👉 https://dev.to/kozerkarol/building-scheduling-timeline-uis-in-react-native-why-it-gets-hard-so-fast-38g2

While solving those problems, I ended up building something bigger.

Introducing a React Native Scheduling / Timeline Component

Hey everyone 👋

I wanted to share something I’ve been working on for quite a while.

I built a React Native time-based scheduling / timeline component designed for:

schedulers
planners
calendars
EPG-style timelines
any UI that represents data across time

And it’s built for real production use cases, not just demos.

Designed for Real Devices

The component works across multiple environments:

iPad & iPhone
Android devices
TV platforms (Android TV and similar)

It supports time-based layouts such as schedules, timelines, and TV guides — where precision, performance, and usability really matter.

Below are short demo videos showing the component running on real hardware:

iPad demo

iPhone demo

Android TV demo

Current Beta Status

The library is currently in beta, and there are a few important notes:

TV navigation

If you plan to use it in a TV environment, you’ll need to implement custom imperative navigation for now.

Native TV navigation is already planned for upcoming releases.

Drag & Drop

Drag & Drop is not available yet in the current beta.

It’s already on the roadmap and will be introduced in a future version.

Looking for Early Testers

I’m currently looking for developers who would like to:

test it in real projects
give feedback
suggest improvements
or just try to break it 😄

If you’re interested, feel free to reach out:

Subject: Planby Native

Email: contact@planby.app

Project website: https://planby.app/

I’d Love Your Feedback

I’d especially love to hear:

what use cases you would try this for
what you expect from a scheduler / timeline component
any developer-experience feedback

Your input will directly shape the next releases.

Final Thoughts

Building time-based scheduling UIs in React Native is far more complex than it first appears.

This library is my attempt to make that problem:

easier to solve
production-ready
performant across mobile and TV
flexible enough for real-world apps

If you’re working on anything involving time, schedules, or timelines, I’d love for you to try it and share your thoughts.

Thanks for checking it out 🙌

jQuery 4.0 in 2026 — A Small Release, A Big Throwback

karolk — Fri, 30 Jan 2026 10:32:59 +0000

The release of jQuery 4.0 in 2026 feels like more than just a version bump — it feels like a time capsule.

For many developers (myself included), jQuery was one of the first tools that made front-end development truly approachable. There was a time when cross-browser issues were everywhere, DOM APIs were inconsistent, and doing simple things in vanilla JavaScript felt unnecessarily complex.

Then jQuery came along with its famous promise: “Write less, do more.”

And it delivered.

Why jQuery Mattered

jQuery wasn’t just a library — it shaped how we thought about frontend development:

Clean DOM selection
Simple event handling
AJAX made accessible
A massive plugin ecosystem

For a whole generation of developers, jQuery was the gateway into JavaScript.

jQuery in a Modern World

Today, we have powerful frameworks, standardized browser APIs, and modern JavaScript features that solve many of the problems jQuery originally addressed.

Most new projects don’t need jQuery anymore — and that’s okay. In a way, its success helped push the web forward to where we are now.

jQuery 4.0 focuses on modernization: removing legacy pieces, aligning with modern standards, and staying lean. It’s not trying to compete with frameworks; it’s evolving to remain relevant where it still makes sense.

A Respectful Nod to the Past

Seeing jQuery reach version 4 in 2026 is a reminder of how fast the ecosystem moves — and how some tools leave a lasting impact.

Even if you don’t use it anymore, chances are jQuery played a role in your journey.

And honestly? That deserves some respect.

Building Scheduling & Timeline UIs in React Native: Why It Gets Hard So Fast

karolk — Tue, 27 Jan 2026 13:07:28 +0000

At first glance, building a scheduling or timeline-based UI sounds straightforward.

You have:

a time axis
some events
maybe a grid

How hard can it be?

If you’ve ever actually built one in React Native, you probably know the answer already:

it gets complicated very quickly.

When scheduling stops being “just a calendar”

Most scheduling UIs start simple:

a daily planner
a basic calendar
a list of time-based items

But real-world requirements show up fast:

hundreds of items on screen
thousands of time-based events
overlapping ranges
multi-day views
smooth scrolling on mobile
gestures (drag, resize, long press)
TV or tablet support

At that point, you’re no longer building a “calendar”.

You’re building a time-based rendering engine.

The biggest pain points (from real projects)

1. Performance with large datasets

Rendering a few events is easy.

Rendering hundreds of rows and thousands of events — not so much.

You start fighting:

dropped frames
memory usage
layout thrashing
scroll jank

Even with virtualization, timelines are harder than lists because:

positions depend on time calculations
items overlap
everything needs to stay aligned to a grid

2. Layout math everywhere

Schedulers are basically math-heavy UIs:

converting timestamps to pixel positions
handling overlaps
snapping to time intervals
recalculating layouts on resize or orientation change

Once you support multiple views (day, multi-day, timeline),

layout logic tends to spread across the entire codebase.

3. Gestures vs. smooth UX

On mobile, gestures are expected:

drag & drop
resizing
scrolling

But combining:

gestures
animations
large datasets

often leads to trade-offs:

smooth scrolling vs. interactive gestures
responsiveness vs. correctness

It’s very easy to end up with a UI that works, but feels fragile.

4. Mobile and TV are different beasts

A lot of scheduling libraries focus on desktop web.

On mobile and TV:

screen real estate is limited
input methods differ (touch, remote control)
performance budgets are tighter

TV especially introduces new challenges:

focus-based navigation
predictable movement
no free-form gestures

Most teams underestimate this until late in the project.

Why many teams end up rebuilding everything

I’ve seen the same pattern over and over:

Start with a simple custom implementation
Add features one by one
Performance starts degrading
More edge cases appear
The scheduler becomes the hardest part of the app

At some point, the scheduler:

takes more time than core product features
becomes risky to modify
is painful to maintain

Yet it’s often mission-critical.

What I learned building a scheduling component

While working on scheduling and timeline-heavy UIs, a few things became clear:

Scheduling UIs are infrastructure, not features
Performance must be designed from day one
Layout and rendering logic needs strong boundaries
Mobile and TV need first-class consideration

Most importantly:

Schedulers shouldn’t be rebuilt from scratch for every project.

Opening the discussion

I’m curious how others approach this in React Native:

Have you built a scheduler or timeline UI before?
What was the hardest part — performance, layout, gestures, scale?
Did you see issues only after data size increased?
Did you build everything yourself or rely on a library?

I’d love to hear real-world experiences and lessons learned 👇

If you’ve fought with scheduling UIs before, you’re definitely not alone.

Build a Monthly Planner in React with Planby PRO (5-Minute Tutorial)

karolk — Wed, 03 Sep 2025 08:35:30 +0000

Today, we’re going to build a Monthly Planner using Planby PRO in less than five minutes. Sounds amazing, right? Imagine how much time you can save with such a powerful tool.

So, what is Planby PRO?
It’s a React component designed for creating advanced timelines and schedules. It comes with powerful features like:

drag & drop support — both internal and external,
timezone handling,
multiple day and day range views,
vertical and horizontal layouts,
super-fast virtual rendering,
and easy third-party integrations.

Website: https://planby.app

Docs: https://docs-pro.planby.app

[Boost]

karolk — Thu, 07 Aug 2025 07:57:59 +0000

karolk

Aug 7 '25

How I Built a Lightweight React Calendar That’s 3 Faster Than FullCalendar

#webdev #react #javascript #reactnative

Comments

2 min read

How I Built a Lightweight React Calendar That’s 3 Faster Than FullCalendar

karolk — Thu, 07 Aug 2025 07:41:24 +0000

😩 The problem with existing React calendars

I love open source. But let's be honest – most calendar or timeline components in React either feel:

bloated (looking at you, FullCalendar)
janky on performance when rendering 100+ events
terrible to style and extend

I needed something that could:

render hundreds of time blocks smoothly
support virtual scrolling
play nice with React state
actually look like something from the 2020s

So I built Planby – a lightweight, modern React timeline/calendar component.

⚡ Meet Planby: A faster, cleaner React timeline

Planby is a customizable, virtualized calendar/timeline component for React and React Native. It supports complex layouts like:

📺 TV program guides (EPG)
🎵 Music festival schedules
🗓️ Multi-day event timelines
📅 Booking and shift management apps

And it’s ~3× faster than FullCalendar in real-world scenarios with 500+ events.

🧠 How it works (without getting too nerdy)

Planby is built around two things:

Virtual rendering – only what's visible is rendered
Canvas-like layout logic – but built entirely in React/DOM

That means:

Smooth performance, even on mobile
Minimal re-renders
Easy customization through React components and props

👇 Here’s how you use it

import { useEpg, Epg, Layout } from '@nessprim/planby-pro';

const channels = React.useMemo(() => [
  {
    logo: 'https://via.placeholder.com',
    uuid: '10339a4b-7c48-40ab-abad-f3bcaf95d9fa',
    title: 'Channel 1',
  },
], []);

const epg = React.useMemo(() => [
  {
    channelUuid: '10339a4b-7c48-40ab-abad-f3bcaf95d9fa',
    id: 'b67ccaa3-3dd2-4121-8256-33dbddc7f0e6',
    image: 'https://via.placeholder.com',
    title: 'My cool show',
    description: 'Ut anim nisi consequat minim deserunt...',
    since: "2024-02-02T20:00:00",
    till: "2024-02-02T21:00:00",
  },
], []);

const {
  getEpgProps,
  getLayoutProps,
  onScrollToNow,
  onScrollLeft,
  onScrollRight,
} = useEpg({
  epg,
  channels,
  startDate: '2024/02/02',
});

return (
  <div style={{ height: '600px', width: '1200px' }}>
    <Epg {...getEpgProps()}>
      <Layout {...getLayoutProps()} />
    </Epg>
  </div>
);

That’s it. Fully functional timeline view. Customizable headers, drag & drop, time indicators — all extendable.

🚀 Why it’s faster

✅ Uses memoized layout calculations

✅ Virtual scroll powered by requestAnimationFrame

✅ No legacy jQuery-style DOM hacks

✅ Built with React 18 in mind (Concurrent Mode ready)

In benchmarks against FullCalendar, Planby renders:

~300% faster initial load with 500+ events
~80% fewer re-renders on scroll
significantly smoother on mobile

🎯 Use cases in the wild

Here’s what people are using Planby for:

TV & streaming guides
Music festival schedules
Logistics shift planning
Healthcare staff rotas
Conference schedules
Even live event dashboards with "Scroll to Now" feature

🔧 Extend it how you want

Need drag & drop? Timezones? Daily/weekly views?

Planby gives you the layout engine — the rest is up to you.

It’s a library, not a framework.

💡 Why I built it

I was building an internal EPG (Electronic Program Guide) tool and got fed up with:

clunky APIs
poor mobile UX
giant bundles

I wrote this post out of frustration.

Now Planby has React Native support, and is used by media companies, startups, and indie hackers alike.

Building Timelines in React Shouldn’t Be This Hard

karolk — Mon, 28 Jul 2025 10:05:15 +0000

❌ Struggling to build performant timeline views in React?

If you’ve ever tried to build a calendar, scheduling tool, or timeline UI in React, you know it’s never as simple as it seems. Especially when you're dealing with:

Hundreds of events across multiple resources (like rooms, people, or stages)
Need for live updates, drag & drop, or zooming
Data that constantly changes or is dynamically fetched
Performance issues with large lists and re-renders
Tight deadlines and clients who want “something like Google Calendar”

That’s where Planby PRO comes in.

✅ Designed for developers building complex, event-driven apps

Planby PRO is a powerful React-based scheduling component built for real-world complexity. Whether you’re creating an event planner, broadcast scheduler, media timeline, or internal dashboard — you shouldn’t have to reinvent the wheel.

Planby PRO solves:

⚡ Virtualized rendering for performance

Even with 500+ events, scrolling and interaction stay buttery smooth.
🧩 Customizable everything

Match your branding, logic, and design — from row height to event tooltips.
⏱️ Ready to integrate in minutes

Simple API, clear docs, and a live demo mean you’re up and running in less than 5 minutes.
🔁 Handles dynamic data

Fetch events, update live, re-render only what’s needed.
🔒 Commercial-ready features

Designed for production — licensed for real business use.

💬 Hear from developers like you:

“We were stuck with scheduling logic for weeks. Planby PRO dropped in seamlessly and just worked.”

— Senior Frontend Developer, Brella

_“Using Planby allowed us to cut the development time for our updated Schedule feature by at least 75% as it supported all the functionalities we designed & were thinking of implementing out of the box!
The other option would've been to create everything from scratch, which would've taken quite a bit some time and we'd have most likely ran into cases that have already been solved by Planby. With it we mostly only needed to adjust the styles, and everything was good to go. We're very happy that we found Planby!"

🛠️ TL;DR: Stop wasting time on complex timeline UIs

If you’ve been hacking around with DIY solutions or bloated full-calendar libraries, Planby PRO gives you a focused, performant, React-native way to handle real scheduling.

👉 Try the live demo

📚 Explore the docs

Need help? Questions? Feedback? Feel free to open an issue or reach out — we’d love to hear from you.

Introducing Planby PRO: The Ultimate Scheduling Solution for Developer

karolk — Thu, 24 Jul 2025 08:27:17 +0000

In today’s fast-paced world, businesses need powerful tools to manage complex schedules, timelines, and live events. Whether you're building a TV guide, project timeline, or live streaming schedule, handling large amounts of data efficiently is crucial. That's where Planby PRO comes in.

What is Planby PRO?

Planby PRO is a highly customizable React-based component designed to streamline the implementation of schedules, timelines, TV guides, and more. It helps developers create intuitive and interactive experiences with minimal setup. Whether you need to manage a small set of data or work with a massive dataset, Planby PRO is built to handle it seamlessly.

Key Features

1. Custom Virtual View for Handling Large Data

One of the standout features of Planby PRO is its ability to work with vast amounts of data without compromising performance. Thanks to its custom virtual view, it ensures smooth scrolling and interaction even when dealing with large schedules or complex event timelines.

2. Easy Integration

Planby PRO is designed with simplicity in mind. The component comes with a simple API that allows for easy integration with any third-party UI libraries. You can get it up and running in less than 5 minutes—perfect for developers looking to save time and get straight to building.

3. Customizable Themes

Whether you're working on a TV guide, event calendar, or a project timeline, the component’s theme can be fully customized to match your app’s design. You can tweak every detail, ensuring that Planby PRO blends seamlessly into your existing UI.

4. Multi-functional Features

Planby PRO offers a broad range of features, including:

Drag-and-drop functionality (DnD)
Group tree support
Time zone support
Vertical/Horizontal view options
Custom render components

It’s versatile enough to fit a wide range of use cases without compromising on flexibility.

Why Use Planby PRO?

As a developer, you need tools that make your life easier. Planby PRO eliminates the complexity involved in building scheduling systems, allowing you to focus on creating great user experiences instead of worrying about performance issues or complicated integration.

The component is ideal for:

TV Guides & Live Streaming Platforms: Schedule and display events in a clean, organized manner.
Project Management Tools: Visualize timelines, task progress, and team collaboration.
Event Management: Build seamless event schedules that are easy to update and manage.

How Does Planby PRO Impact Your Business?

Planby PRO isn’t just a tool—it’s a productivity booster. Here’s how it helps businesses:

Reduced Development Time: With its easy setup and customizable features, you can implement Planby PRO quickly and efficiently.
Enhanced User Experience: The smooth performance and intuitive interface result in better user engagement.
Scalability: Whether you’re working with a small project or a large-scale application, Planby PRO scales to meet your needs without compromising performance.

Real-World Use Cases

Several companies have already integrated Planby PRO into their systems. Early feedback highlights that it saves them valuable development time and provides robust, easy-to-use features that keep users coming back.

For example, media companies have used it to create dynamic TV schedules, while event organizers have built interactive event timelines that update in real-time.

The Future of Planby PRO

We’re constantly evolving Planby PRO based on feedback from our users. New features are on the way, and we’re committed to ensuring it remains one of the most efficient, flexible scheduling solutions on the market.

Conclusion

If you’re a developer looking for a reliable, customizable scheduling component, Planby PRO is your go-to solution. With its seamless integration, scalability, and focus on user experience, it’s designed to make your life easier and help you build better applications faster.

Check it out today, and start building your next project with Planby PRO! 🚀

Feel free to connect with me if you have any questions or suggestions. I'd love to hear how you’re using Planby PRO in your projects!
Website: https://planby.app

[Boost]

karolk — Fri, 31 Jan 2025 12:29:03 +0000

Introducing Planby Now: The Ultimate No-Code Tool for Effortless Scheduling and Planning

karolk ・ Jan 31

Introducing Planby Now: The Ultimate No-Code Tool for Effortless Scheduling and Planning

karolk — Fri, 31 Jan 2025 12:28:47 +0000

In today’s fast-paced world, efficiency is key, and having the right tools at your disposal can make all the difference. Enter Planby Now, the latest no-code solution on the market designed to help you deploy your schedule, timeline, planner, calendar, and more—faster than ever before.

This innovative platform simplifies the entire process, allowing users to import data directly from CSV files, customize their setup to meet specific service needs, and integrate seamlessly into their existing websites or applications. Whether you’re a non-technical user or a seasoned developer, Planby Now offers a tailored experience that suits everyone.

Why Planby Now Stands Out

1. Rapid Deployment

With Planby Now, you can set up your schedule or planner in minutes. Gone are the days of struggling with complex tools or endless configurations. Simply upload your data from a CSV file, customize the interface to your liking, and you’re good to go.

2. Seamless Integration

For Non-Technical Users: Integrating your schedule into platforms like WordPress, Framer, or Webflow has never been easier. Just copy a single link, and you’re all set—no coding required.
For Developers: Add a single line of code to embed your schedule into any application, using Planby Now as a CMS. The simplicity and flexibility ensure that your workflow remains smooth and efficient.

3. Comprehensive API Support

Want more control? Use the Planby Now API to connect the platform to your existing tools and systems. This makes it perfect for teams looking to centralize their planning and scheduling workflows. With robust CMS functionality, Planby Now can act as a powerful backend solution for you and your team.

Exceptional User Experience

What truly sets Planby Now apart is its focus on modern UX/UI design. The dashboard is not only visually stunning but also intuitive and user-friendly, ensuring that you can manage your tasks effortlessly. It’s a tool built with users in mind, offering an experience you won’t find anywhere else.

All-in-One Solution

Whether you need a planner, calendar, or CMS, Planby Now combines everything into one convenient platform. It eliminates the need for multiple tools, streamlining your workflow and saving you time and effort.

Who Can Benefit from Planby Now?

Small business owners looking to integrate schedules into their websites quickly.
Freelancers seeking an easy way to manage and display timelines for clients.
Developers needing a customizable CMS solution for planning and scheduling.
Teams who require centralized management for schedules and projects.

Ready to Try Planby Now?

Experience the ease and power of Planby Now for yourself. Whether you’re creating a schedule for your website, managing a timeline, or using the platform as a CMS, this innovative tool has you covered.

Start your journey with Planby Now today and revolutionize the way you handle schedules and planning.