Let’s talk feature upvoting. You’ve got feedback flying in from every direction. Emails, Slack, Twitter DMs, random Notion docs... it's a mess. What you actually need is a clean, simple way to gather ideas, let your users vote on what they care about, and actually ship stuff people want. That is where upvoting tools come in.

Here’s a breakdown of the best options out there. We’re starting with Upvoted because it deserves that top spot.

---

1. Upvoted: The Feedback Board That Doesn’t Suck

Obviously I’m a little biased here, but seriously. Upvoted is not just another voting board. It is built to be useful for real teams and real users. You can spin up public or private boards in seconds, drop a widget anywhere on your site, and just like that, you're collecting feedback that actually means something.

What makes it great:

• You collect smart feedback. Users can upvote, comment, and request features all in one spot.
• You build with purpose. Turn feedback into a visual roadmap that tracks progress from "proposed" to "published."
• You choose your visibility. Go public to get the community involved or stay private for internal team planning.
• You embed it anywhere. One line of code and you are good to go. No hassle, no dev time wasted.
• You keep everyone aligned. From stakeholders to engineers, everyone stays in the loop.

Pricing options:

• Standard plan is $15.20 per month
• Lifetime deal is $232 one-time. No recurring fees, ever.

If spreadsheets are your current "feedback system," trust me, it’s time for an upgrade.

Subscribe now: Upvoted

---

2. Canny: The OG With Enterprise Vibes

Canny has been around for a while and it shows. It is polished, feature-packed, and integrates with all the big tools. Enterprise teams love it, but it can feel like overkill if you are running a lean operation.

Pros:

• It integrates with tools like Intercom, Slack, and Jira
• Great choice for larger teams with big budgets

Cons:

• Gets expensive fast if you scale up
• Less flexibility for doing things your own way

---

3. Nolt: Super Clean and Straightforward

Nolt is a go-to for indie makers and small startups. It is simple and it works. No fluff.

Why people love it:

• Setup is ridiculously fast
• Public roadmaps look sleek and polished

Limitations to keep in mind:

• Workflow options are limited
• Private boards are locked behind higher tiers

---

4. Sleekplan: Feedback, Surveys, and Changelog All in One

Sleekplan goes beyond just upvoting. It adds surveys, changelogs, and a bunch of other feedback tools. It is like a Swiss Army knife for product teams.

Good for:

• Teams that want a complete feedback suite
• Creating a full feedback loop, from suggestion to release

Not so good for:

• Simple needs. If you only want upvotes and a roadmap, it might be overkill
• The interface takes a bit of getting used to

---

If you want a modern, clean, and user-friendly way to collect feedback, prioritize features, and build a roadmap that people actually follow, go with Upvoted. It is straightforward, flexible, and priced in a way that makes sense.

Give it a try. Launch a board, share it with your users, and start making data-backed product decisions right away.

Hey there, fellow developers!

Today I want to talk about two popular web frameworks that continue to make waves in the development world: Ruby on Rails and Phoenix. If you're trying to decide between these two for your next project, this comparison might help you make that choice.

The Contenders

Ruby on Rails has been around since 2004 and revolutionized web development with its "convention over configuration" philosophy. It's built on Ruby and has matured into a stable, feature-rich framework with a massive community.

Phoenix is the newer kid on the block, built on Elixir (which runs on the Erlang VM). It first appeared in 2014 and has been gaining traction for its performance and scalability benefits.

Development Speed and Productivity

Rails is famous for getting projects off the ground quickly. Its generator commands, built-in testing, and vast library of gems mean you can set up a full-featured app in no time.

# Creating a new Rails app with a database and scaffolding
rails new my_blog
cd my_blog
rails generate scaffold Post title:string content:text
rails db:migrate

Phoenix also values developer productivity but has a slightly steeper learning curve if you're new to functional programming. That said, once you're comfortable with Elixir, Phoenix's generators are just as powerful.

# Creating a new Phoenix app with database support
mix phx.new my_blog
cd my_blog
mix phx.gen.html Content Post posts title:string content:text
mix ecto.migrate

Performance

This is where things get interesting:

Rails is plenty fast for most applications, but it's not known for raw performance. Ruby is an interpreted language, and while it's gotten faster over the years, it's not winning any speed competitions.

Phoenix absolutely shines here. Built on the Erlang VM, Phoenix can handle an enormous number of concurrent connections with minimal resources. Real-world benchmarks often show Phoenix handling 5-10x more requests per second than Rails on the same hardware.

Scalability

Rails scales horizontally well enough (adding more servers), but vertical scaling (adding more to one server) hits limits due to Ruby's concurrency model.

Phoenix/Elixir was built for distribution and fault tolerance. The Erlang VM was designed by telecom engineers who needed systems that never go down, even during upgrades. Phoenix inherits this robustness and can effortlessly spread across multiple cores and machines.

Real-time Features

Rails added ActionCable for WebSockets support, which works well for moderate real-time needs, but it's not Rails' strongest feature.

Phoenix has Channels, a robust real-time communication layer that's a core part of the framework rather than an add-on. Phoenix is famous for its benchmark where they handled 2 million WebSocket connections on a single (beefy) server.

Community and Ecosystem

Rails has a massive community with thousands of gems (libraries) for almost anything you could want. It's supported by major companies and has been battle-tested for nearly two decades.

Phoenix has a smaller but rapidly growing community. The ecosystem doesn't have the same breadth as Rails yet, but the quality of the libraries tends to be high.

Learning Curve

Rails is fairly easy to pick up, especially if you already know Ruby. Its conventions make sense once you understand them, and there are tons of tutorials available.

Phoenix requires learning Elixir first, which is a functional language. If you're coming from object-oriented programming, this shift in thinking can take time to adjust to. However, Elixir is known for its excellent documentation and friendly syntax.

Jobs and Market Demand

Rails still has a strong job market, especially in startups and established companies that adopted it during its heyday.

Phoenix jobs are fewer but growing. Companies that need high concurrency or real-time features are increasingly turning to Elixir and Phoenix.

Which Should You Choose?

Here's my take:

Choose Rails if:

• You need to build something quickly with a proven stack
• Your app has standard web app requirements
• You want easy hiring and a huge ecosystem of libraries
• You're already familiar with Ruby or similar OOP languages

Choose Phoenix if:

• Your app needs to handle high concurrency
• Real-time features are central to your application
• You're interested in functional programming
• You're building something that needs high reliability or fault tolerance

My Two Cents

Both frameworks are awesome in their own ways. Rails continues to evolve and remains a highly productive choice for web development. Phoenix represents where web development is heading, with built-in support for the real-time, highly-concurrent apps that are increasingly in demand.

In 2025, I think Rails is still the safer choice for most standard web applications, but Phoenix is the better technical choice for applications that need to scale massively or have significant real-time components.

Shhh... not everyone knows this one.

If you're running a high-traffic Phoenix app and notice bottlenecks around frequently accessed data (like config settings, permissions, or feature flags), there's a dead-simple way to massively cut down latency—without reaching for Redis or another external cache layer.

Here’s the move: use Erlang’s built-in :ets (Erlang Term Storage) for in-memory reads at lightning speed. Think microsecond access times.

⚡ Why this works

:ets is managed by the BEAM, lives in memory, and supports concurrent read access. It's ideal for lookups that rarely change but are read constantly.

🔧 Example: Caching user roles

Let’s say you’re hitting the database every time you check a user’s role. Here’s a sneakier way:

defmodule MyApp.RoleCache do
  @table :role_cache

  def init do
    :ets.new(@table, [:named_table, :set, :public, read_concurrency: true])
  end

  def put(user_id, role) do
    :ets.insert(@table, {user_id, role})
  end

  def get(user_id) do
    case :ets.lookup(@table, user_id) do
      [{^user_id, role}] -> {:ok, role}
      [] -> :miss
    end
  end
end

Drop this into an app startup hook (e.g., MyApp.Application.start/2) to initialize the table.

🚀 Pro tip: Layer it with fallback logic

def get_or_fetch(user_id) do
  case get(user_id) do
    {:ok, role} -> role
    :miss ->
      role = MyApp.Repo.get_role_from_db(user_id)
      put(user_id, role)
      role
  end
end

🧠 Remember

• Keep data small and fast-changing stuff out of it.
• :ets tables don’t persist across node restarts—use it strategically.
• For true distributed caching, you'll want to look into :global, :mnesia, or external layers. But for local, hot-path reads? This is chef’s kiss.

You didn’t hear it from me. But this one tweak? Could be your secret edge. 🕶️

If you’ve been building APIs with GoFiber, you’ve probably had that moment where your route handler starts to get a little... messy. Especially when you’re doing request validation right inside the handler.

Let’s talk about a simple tip to clean that up using middleware — it’s easy, reusable, and your future self will thank you.

😬 The Messy Way (We've All Done It)

Here’s what a typical handler might look like at first:

app.Post("/users", func(c *fiber.Ctx) error {
	type UserRequest struct {
		Name  string `json:"name"`
		Email string `json:"email"`
	}

	var body UserRequest
	if err := c.BodyParser(&body); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": "Invalid request body",
		})
	}

	if body.Name == "" || body.Email == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": "Name and Email are required",
		})
	}

	// Do the thing
	return c.JSON(fiber.Map{"message": "User created"})
})

This works fine at first, but as your API grows, stuffing all the parsing and validation into your handlers gets old real quick.

✨ The Cleaner Way: Middleware

Let’s move the validation logic out of the handler and into a middleware. That way, your handler can focus on doing what it’s actually meant to do.

🧱 Step 1: Define Your Request Struct

type UserRequest struct {
	Name  string `json:"name"`
	Email string `json:"email"`
}

🧼 Step 2: Write a Middleware to Validate It

func ValidateUserRequest(c *fiber.Ctx) error {
	var body UserRequest

	if err := c.BodyParser(&body); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": "Invalid JSON body",
		})
	}

	if body.Name == "" || body.Email == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": "Name and Email are required",
		})
	}

	// Pass the validated body to the next handler
	c.Locals("userBody", body)

	return c.Next()
}

🧑‍🍳 Step 3: Use It in Your Route

app.Post("/users", ValidateUserRequest, func(c *fiber.Ctx) error {
	body := c.Locals("userBody").(UserRequest)

	// Clean and easy
	return c.JSON(fiber.Map{
		"message": "User created",
		"user":    body,
	})
})

Nice and tidy. You’re only dealing with the stuff you care about inside the handler.

🏆 Why This Rocks

• Separation of concerns – Validation and logic are in their own lanes.
• Reusability – You can reuse the same middleware for other routes.
• Testability – Easier to test your logic without worrying about request parsing every time.

💪 Bonus: Use a Validation Library

Want to step it up a notch? Add go-playground/validator for fancy rules like email format, string length, etc.

go get github.com/go-playground/validator/v10

Then tweak your middleware:

import "github.com/go-playground/validator/v10"

var validate = validator.New()

type UserRequest struct {
	Name  string `json:"name" validate:"required"`
	Email string `json:"email" validate:"required,email"`
}

func ValidateUserRequest(c *fiber.Ctx) error {
	var body UserRequest
	if err := c.BodyParser(&body); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid body"})
	}

	if err := validate.Struct(body); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	c.Locals("userBody", body)
	return c.Next()
}

Now your validation is way more powerful, but still just as clean.

👋 Final Thoughts

Keeping your GoFiber handlers clean doesn’t have to be complicated. With a little middleware magic, you can offload the grunt work like validation and keep your handlers laser-focused.

Try it out on your next API project. Your code (and teammates) will be happier for it.

Phoenix LiveView has reached a significant milestone with the release of version 1.0. This update brings a host of enhancements and refinements, solidifying LiveView's position as a robust solution for building real-time, interactive web applications with Elixir.

In this post, we'll explore the key features of Phoenix LiveView 1.0 and discuss what this means for developers.

What is Phoenix LiveView?

Phoenix LiveView is an Elixir library that enables developers to create rich, real-time user interfaces without writing extensive JavaScript. By leveraging server-rendered HTML over WebSockets, LiveView maintains a persistent connection between the client and server, allowing seamless UI updates with minimal latency. This approach simplifies the development process and ensures a consistent, maintainable codebase.

Key Features of Phoenix LiveView 1.0

1. Faster and Smaller Updates

LiveView 1.0 introduces optimized data transfer between the server and client. Instead of re-sending entire pages, LiveView now transmits only the necessary diffs, resulting in faster updates and reduced bandwidth usage. This enhancement significantly improves the performance of real-time applications.

2. Improved Lifecycle Hooks

The new version offers enhanced lifecycle hooks, providing developers with more control over the component lifecycle. This improvement facilitates better resource management and more efficient handling of component state changes.

3. Removal of phx-feedback-for

In an effort to streamline the API, LiveView 1.0 removes the phx-feedback-for annotation previously used for input validation feedback. Developers are encouraged to use the new Phoenix.Component.used_input?/2 function for handling input feedback. For those maintaining existing applications, a backward-compatible shim is available to ease the transition.

4. Stability and Production Readiness

Reaching the 1.0 milestone signifies that Phoenix LiveView is stable and ready for production use. This release reflects the maturity of the library and its capability to handle complex, real-time web applications reliably.

Upgrading to Phoenix LiveView 1.0

For developers currently using earlier versions of LiveView, upgrading to 1.0 is straightforward. It's essential to review the changelog for any backward-incompatible changes and to test your application thoroughly after the upgrade. Particularly, attention should be given to the removal of phx-feedback-for and the adoption of Phoenix.Component.used_input?/2.

Conclusion

The release of Phoenix LiveView 1.0 marks a significant advancement in the Elixir ecosystem, offering developers a powerful tool for building real-time, interactive web applications with ease.

By reducing the reliance on JavaScript and embracing server-side rendering, LiveView simplifies the development process and enhances application performance.

As the community continues to adopt and build upon this foundation, we can anticipate even more innovative applications and improvements in the future.