Bricks + ACF Dynamic
Directories, portfolios, real estate, job boards, multi-content-type sites - built dynamic and maintainable from day one.
The problem
When every new listing, profile, or entry needs a developer to create a new page, your site stops being a publishing platform and starts being a bottleneck. Dynamic architecture fixes this - but only if it's modelled correctly from the start.
Every new listing, team member, or property requires a developer to create a new page. Your content team is blocked waiting for dev time on routine updates.
+ bottleneckThe same data entered in multiple places - page content, sidebar widgets, footer links - because there is no single source of truth. One change means updating five locations.
+ driftWordPress default search is basic - it searches post content, ignores custom fields, and has no concept of faceted filtering. Your users expect to narrow results by category, price range, location, and date. They get a keyword box.
+ frustrationWhat you get
What we don't do
Agency-safe workflow
Your agency stays front-and-center. We handle the CPT, ACF, query-loop, template, and maintenance notes behind your brand, with technical context your team can review before client handoff.
Custom post types, ACF field groups, naming conventions, and editor-facing assumptions are captured clearly.
Single, archive, taxonomy, listing, and reusable section decisions are mapped to the data model.
Query-loop conditions, relationship logic, related-content rules, and empty states are documented.
Taxonomy, filter, search, facet, and URL-state assumptions are separated from core template work.
Data dependencies, content-entry rules, and maintenance risks are called out before handoff.
Your team gets a concise reference for updating fields, templates, filters, and content structures later.
Built to be reviewed by your agency. The handoff documents assumptions and boundaries so the data model stays understandable after launch.
Execution quality
A quick look at the kind of structured Bricks work, component thinking, and operational handoff your agency can expect before anything reaches the client.
Review
The content model is reviewed before templates are treated as finished, so dynamic structure is not left to guesswork.
Model before templates
Architecture drives the build.
CPTs, field groups, templates, loops, filters, and editor workflows are connected in handoff notes.
Mapped structure
The agency can inspect the system.
Facets, taxonomy behavior, search assumptions, and empty states are documented where they affect the build plan.
Boundaries documented
No app-like overpromise.
Admin UX, content-entry notes, and maintenance guidance are grouped for the agency before client training.
Editor-ready notes
The back end is part of the handoff.
Reviews
We know that outsourcing can feel like a risk. These reviews reflect our commitment to the fundamentals of a seamless partnership. Judge us by the habits that matter most to your timeline: hitting deadlines, writing maintainable code, and keeping communication clear.
I have worked with Ranjan several times in the past. He is knowledgeable, efficient, and always very professional. He went the extra mile to ensure additional levels of security were in place to help protect our investment in the future.
Ranjan was fantastic to work with. His coding expertise is top-notch, he quickly understood my needs and delivered clean, efficient work. Very professional, polite, and always respectful of deadlines.
My website is now lightning fast thanks to his technical optimization work. He was polite, extremely cooperative, and went above and beyond to help my business.
The deliverable was far faster than I expected and excellent quality work. If I need WordPress services again, I would not hesitate to ask Ranjan first. He clearly knows what he is doing with WordPress.
Very professional and skilled web designer. The website was delivered exactly as requested, with great attention to detail. Communication was smooth, and everything was completed on time.
I have worked with a lot of designers and Ranjan is top-tier. Will order again.
Highly recommend for challenging hosting and WordPress requirements. He handled a complex technical migration quickly and flawlessly, with zero issues.
The process was simple and efficient. I'm really pleased with the outcome.
Perfect service from start to finish. Thank you, Ranjan.
He did an excellent job, and I'm pleased with the results. He brought great suggestions throughout the project, many of which we incorporated. I'd likely work with him again.
Amazing, fast, and absolutely worth recommending.
The professionalism, code expertise, and attention to detail were top-notch. Excellent communication, quick responses, and great cooperation. Highly skilled in WordPress setup.
This might be my fifth order with Ranjan. I highly recommend his services. He helped resolve a complex WooCommerce performance issue and got the backend working smoothly.
Ranjan exceeded expectations with his code expertise and professionalism in web development. His deep understanding and proactive communication made working with him a breeze.
Ranjan's professionalism and code expertise made this project a success. His proactive communication and politeness made the collaboration even better. Highly recommended.
He consistently delivered high-quality work on time across every project I assigned him. I highly recommend him.
Ranjan was responsive and understanding throughout the work. I'd happily work with him again.
Excellent work as normal.
Working with Ranjan and team was great. Wonderful work.
Pricing
1 CPT, basic ACF, archive + single templates
Starting at $1,500 fixed quote after review
2-3 CPTs, relational fields, faceted filtering
From $3,000 fixed quote after review
Complex relationships, custom query logic, REST API, multilingual
From $5,500+ quote only
Starting prices shown; most Standard-tier systems fall between $3,000 and $5,500. Final fixed quote after content modeling session, with one revision round included and timeline confirmed at quote. Third-party licences and hosting are billed separately. Custom query logic, REST integrations, or multilingual work beyond the modeled deliverables is quote only. Ongoing edits available under the Bricks Care Plan.
How we work
60–90 minute working session where we map your content to CPTs, fields, taxonomies, and relationships. We model on a whiteboard - no code yet. This is where bad data models get caught before they become bad builds.
Written spec covering every CPT, field group, taxonomy, template, query loop, and filter. You approve the architecture before a single field is created. Deliverables is locked at this stage.
Register CPTs and taxonomies, build ACF field groups with conditional logic, set up field naming conventions, configure Admin Columns Pro. The data layer is built first - templates come after.
Build single, archive, and taxonomy templates in Bricks. Every block uses dynamic data - ACF field tags, query loops, conditional visibility rules. Nothing is hard-coded.
Configure FacetWP facets and listing templates. Set up search indexing for custom fields and taxonomies. Test filtering combinations, URL state, and empty-state handling.
Tune the WordPress admin - column configuration, field group layout, content entry instructions. Test with sample content across all CPTs. One revision round applied.
Loom walkthrough of the full admin experience - creating entries, using field groups, managing taxonomies. Written documentation covering the data model, template structure, and content entry guide. Your team is self-sufficient from day one.
Why us
# CPT: Properties
post_type → property
taxonomies → location, type, status
field_group → property_details (14 fields)
relationships → agent (post_object, bi)
archive_tpl → query loop + facets
single_tpl → dynamic data, gallery, mapEvery project ships a full architecture document before build begins - deliverables, quote, and timeline locked to the plan.
FAQ
We default to ACF Pro - it has the largest ecosystem, the best Bricks Builder integration, and the most documentation. Meta Box is a strong alternative when you need custom tables instead of postmeta storage (better query performance at scale). Pods is good for rapid prototyping but less flexible at the templating layer. We recommend based on your specific data model and scale - not from brand loyalty.
Yes - this is one of the main reasons clients come to us. We integrate FacetWP with your CPTs and ACF fields, building filter UIs that let users narrow by taxonomy, custom field values, date ranges, and more. For simpler needs, we build custom query-filter loops directly in Bricks without an extra plugin.
We set up multilingual dynamic sites using WPML or Polylang, configuring translatable CPTs, taxonomies, and ACF field groups. Templates work across all languages without duplication. Multilingual is included in our Premium tier.
Yes. We expose any CPT and ACF field through the WordPress REST API - custom endpoints, filtered responses, paginated results, and authenticated routes if needed. Useful for headless frontends, mobile apps, or cross-platform syndication. REST API is covered in Premium and available as a Standard add-on.
We model relationships at the architecture stage - using ACF relationship fields, post object fields, or bidirectional relationships via ACF Extended. For many-to-many or deeply nested links, we design the query strategy to avoid N+1 problems and keep page loads fast.
Yes - we handle migration from other platforms into WordPress CPTs with ACF fields. We build import scripts (WP All Import, custom WP-CLI commands, or direct database migration) that map your old structure to the new architecture. Import complexity is defined during the architecture document phase.
Admin UX is part of every build. We configure Admin Columns Pro so editors can see, sort, and filter entries without opening each post. ACF field groups are organized logically with labels that match your team's vocabulary. We also set up draft/publish pipelines, required-field validation, and inline help text.
Fill out the form on this page with a description of your content types, approximate number of entries, and any filtering/search requirements. We'll schedule a content modeling session - a 60–90 minute call where we map your content to CPTs, fields, and relationships. After that, we deliver an architecture document with a fixed quote. Start your project →
Start your build
Describe your content types and requirements. We will schedule a content modeling session and deliver a fixed quote with an architecture document.